動態規劃算法

動態規劃是什麼

動態規劃（Dynamic Programming，DP）是運籌學的一個分支，是求解決策過程最優化的過程。20世紀50年代初，美國數學家貝爾曼（R.Bellman）等人在研究多階段決策過程的優化問題時，提出了著名的最優化原理，從而創立了動態規劃。

咱們把要解決的一個大問題轉換成若干個規模較小的同類型問題，當咱們求解出這些小問題的答案，大問題便不攻自破。這就是動態規劃。

看一個很經典的介紹 DP 的問題：
「How should i explain Dynamic Programming to a 4-year-old?「
writes down "1+1+1+1+1+1+1+1 =" on a sheet of paper
"What's that equal to?"
counting "Eight!"
writes down another "1+" on the left
"What about that?"
quickly "Nine!"
"How'd you know it was nine so fast?"
"You just added one more"
"So you didn't need to recount because you remembered there were eight! Dynamic Programming is just a fancy way to say 'remembering stuff to save time later'"

這個估計你們都能看懂，就不解釋了。動態規劃其實就是把要解決的一個大問題轉換成若干個規模較小的同類型問題。那這裏的關鍵在於小問題的答案，能夠進行重複使用，好比經典的爬樓梯問題。

這種思想的本質是：一個規模較大的問題（能夠用兩三個參數表示），經過若干規模較小的問題的結果來獲得的（一般會尋求到一些特殊的計算邏輯，如求最值等）

咱們通常看到的狀態轉移方程，基本相似下面的公式（注：i、j、k 都是在定義DP方程中用到的參數。opt 指代特殊的計算邏輯，大多數狀況下爲 max 或 min。func 指代邏輯函數）：

• dp[i] = opt(dp[i-1])+1
• dp[i][j] = func(i,j,k) + opt(dp[i-1][k])
• dp[i][j] = opt(dp[i-1][j-1],dp[i-1][j])+arr[i][j]
• dp[i][j] = opt(dp[i-1][j] + xi, dp[i][j-1] + yj, ...)
• ...

基本思路

動態規劃是一個求最值的過程，既然是要求最值，核心問題是什麼呢？求解動態規劃的核心問題是窮舉。由於要求最值，確定要把全部可行的答案窮舉出來，而後在其中找最值。

首先，動態規劃的窮舉有點特別，由於這類問題存在「重疊子問題」，若是暴力窮舉的話效率會極其低下，因此須要「備忘錄」或者「DP table」來優化窮舉過程，避免沒必要要的計算。
並且，動態規劃問題必定會具有「最優子結構」，才能經過子問題的最值獲得原問題的最值。
最後，雖然動態規劃的核心思想就是窮舉求最值，可是問題能夠變幻無窮，窮舉全部可行解其實並非一件容易的事，只有列出正確的「狀態轉移方程」才能正確地窮舉。

總體框架

• 狀態轉移方程
• 備忘錄存儲重複子問題
• 最小子問題
• 求最值

斐波那契數列

斐波那契數列不算動態規劃，可是解決問題的思路與動態規劃很像，再加上你們上學的時候基本都接觸過斐波那契數列，經過它來理解動態規劃就很不錯了。

斐波那契數列的數學形式就是遞歸的，寫成代碼就是這樣：

int fib(int N) {
    if (N == 1 || N == 2) return 1;
    return fib(N - 1) + fib(N - 2);
}

這個遞歸，相信有很多人能看出問題，子問題被不斷計算，以N=20爲例
fib(20) = fib(19) + fib(18) = fib(18) + fib(17) + fib(18)
寫到這裏，已經發現，fib(18)已經被計算屢次，效率很低下。

因此引入帶備忘錄的遞歸算法，把每次計算的子結果的值進行存儲，後面就不須要重複計算了。整改以後的代碼

int fib(int N) {
    int[] dp = int int[N];
    // 最小子問題
    dp[1] = dp[2] = 1;
    for (int i = 3; i <= N; i++) {
        // 狀態轉移方程
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[N];
}

例子：最長迴文串

問題：給定一個字符串 s，找到 s 中最長的迴文子串。你能夠假設 s 的最大長度爲 1000。

輸入: "babad"
輸出: "bab"
注意: "aba" 也是一個有效答案。

思路：對於一個子串而言，若是它是迴文串，而且長度大於2，那麼將它首尾的兩個字母去除以後，它仍然是個迴文串。例如對於字符串「ababa」，若是咱們已經知道「bab」 是迴文串，那麼「ababa」 必定是迴文串，這是由於它的首尾兩個字母都是「a」。
因而獲得咱們的狀態轉移方程：

dp[i][j] 表示i到j之間的字符串是不是迴文串
dp[i][j] = dp[i+1][j-1] and (s[i] eq s[j])
最小子問題：當s[i] eq s[j]，子串長度是2或3，不須要檢查子串是否迴文串，即j-i<=2

public String longestPalindrome(String s) {
    if (s == null || s.length() <= 1) {
        return s;
    }

    int len = s.length();
    int maxLen = 1;
    int left = 0;
    int right = 0;
    boolean[][] dp = new boolean[len][len];
    char[] chars = s.toCharArray();

    // 若是i從0開始，那麼對應abba這樣的字符串，bb這個子串在遍歷過程當中無法被當作子問題進行存儲
    for (int i=len-2; i>=0; i--) {
        for (int j=i+1; j<len; j++) {
            if (chars[i] == chars[j]) {
                if (j-i <= 2) {     // 最小字問題
                    if (j-i+1 > maxLen) {
                        maxLen = j-i+1;
                        left = i;
                        right = j;
                    }
                    dp[i][j] = true;
                }else if (dp[i+1][j-1]) {   // 子問題
                    if (j-i+1 > maxLen) {
                        maxLen = j-i+1;
                        left = i;
                        right = j;
                    }
                    dp[i][j] = true;
                }
            }
        }
    }

    return s.substring(left, right + 1);
}