動態規劃解題方法

碼農田小齊發表於2021-01-15

魔幻的 2020 讓我們懷疑人生是否存在最優解?我們某個時間的決策究竟是否正確?歷史不能改變,但卻會重演,我們究竟要從過去中學到什麼呢?

讓我們一起從動態規劃中,來找尋這些問題的答案吧~

(咳咳,今天開始迴歸演算法系列,來聊一聊之前的演算法文章中沒有講到的內容。

什麼是動態規劃

動態規劃(Dynamic Programic,簡稱 DP)是一種求解最優解的方法,它是一種特殊的分治思想,利用它可以實現時間複雜度的優化,有時也可以進行空間複雜度的優化,有時是需要更多的空間的(相比其他方法)。

dynamic 是動態的意思,也就是變化的,programing 可以理解為方程(我瞎說的),結合起來就是動態規劃是用狀態轉移方程來求得最優解的演算法。

在解釋動態規劃的時候,我們順便理一理和它相關的兩種思想——分治和貪心演算法。

分治

分治是把大問題分解成若干個子問題,這樣的能分解性質就是最優子結構的。

最簡單的例子就是小明在解決問題 A 的時候,發現問題 A 是由問題 B 和 C 一起組成的,所以他想要解決問題 A,就需要把 B、C 一起去解決。

動態規劃

動態規劃是分治法的特例。

動態規劃比分治法多了一種,就是重疊的子問題。

什麼是重疊的子問題呢?舉個例子來講,可愛的小明遇到了一個可愛的問題,那就是問題 A,但是在前面需要解決一連串的問題,我們用A1,A2,A3,A4 ... A來表示,在解決A1之後會用它的解去解決類似的問題A2
然後再去解決A3,最終再去解決 A,這就是重疊的子問題的典型代表。(下面的例題還會解釋這個概念)

貪心

貪心比動態規劃更加的特殊,它還需要問題滿足另外一個性質——貪心選擇性質,每次都可以把原問題分解成為一個子問題。

實際上再用動規的例子來說明貪心,在解決A1,A2,A3,A4 ... A的時候,他發現解決不光有一種重疊子問題的性質在裡面,更有趣的是,解決A1需要一種特殊的規則。

例如小明現在在玩電腦遊戲,而電腦遊戲的最終目的是到達A,而他又發現,只要一直往右邊走就能到達最終的目的地了。這就是一種貪心的演算法,在每次往右邊走,就是一種特殊的規則,而走到目的地A需要很多重複的子問題,也即每次活動一個單位。

入門

其實在很久之前我寫的一篇文章中,以斐波那契數列這道基本題為例,詳細闡述了從遞迴到 DP 的優化方法和思路,以及簡單題的不簡單的答法,大家不妨先去複習一下:

這才是面試官想聽的:從遞迴到 DP 的優化

然後我們再來看看一般的動態規劃解題思路。

解題思路

回到動態規劃,這裡有四個基本的概念:

  • state(狀態表示)
  • function(轉移方程)
  • initial(初始化)
  • final state(最終的狀態)

在剛開始的時候,我們首先需要構建一個儲存資料的表格,一般是陣列或者矩陣,然後設定好每一個格子到下一個格子需要的轉移方程。

然後去執行重複的步驟,從初始化的狀態一直計算到最終需要的狀態。

回到小明的例子,剛開始的時候小明需要確定一個 state(A0代表的是什麼),然後找到A0A1之間的關係,從初始化開始一直計算到最終的狀態。

接下來,我們以 Leetcode 120 來詳細的講解這個演算法。

題目描述

現在我們來分析一下這個題目,首先我們分析一下為什麼它是一個動態規劃的問題。

題目是要找到一種路徑的和,這種路徑和是要最小的,也就是求一個最優解

因為這是路徑,我們就是在每一層裡面選擇一個合適的數字,然後連成一個路徑,在這道題目裡面,最小的路徑是2-3-5-1,在第一層挑了2,在第二層挑了3。也就是說總的問題拆分成了每一層的問題,而每一層之間都有一種依賴性在裡面,例如第二層選擇了3之後只能在6,5之中選擇一個,不能跳到7,這就是重疊子問題

我們用f[i][j]表示從三角形頂部走到位置 [i][j] 的最小路徑和。這裡的位置 i, j 指的是三角形中第 i 行第 j 列的位置。

由於只能是從一個節點到相鄰的兩個節點(樹),因此要想走到位置 [i][j],上一步就只能在位置 [i-1][j-1] 或者位置 [i-1][j]

我們在這兩個位置中選擇一個路徑和較小的來進行轉移,狀態轉移方程為:

f[i][j]=min(f[i−1][j−1],f[i−1][j])+c[i][j]

其中 c[i][j] 指的是triangle[i][j]的數值。

方法一

當設定完通項方程之後,我們還需要設定一些特殊的轉化方程:

  • 當靠近左邊界時,也就是 j = 0 時,於是沒有f[i-1][j−1]這一項 ,狀態轉移方程變為:

f[i][0]=f[i−1][0]+c[i][0]

  • 當靠近右邊界時,我們直接用上一層斜上角位置的數值進行計算:

f[i][i]=f[i−1][i−1]+c[i][i]

最終,我們只需要在 dp 三角形的最後一行找到最小值就可以了。

那麼初始的狀態是什麼呢?

實際上就是剛開始的時候設定 dp 的第一個單位的數值為cp[0][0],也即是dp[0][0] = c[0][0]

狀態轉換圖如下所示:

程式碼如下:

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
       // 建立表格
        int[][] dp = new int[triangle.size()][triangle.size()];
        dp[0][0] = triangle.get(0).get(0);
       // 動態規劃的方程式
        for (int i = 1; i < dp.length; i++) {
            for (int j = 0; j <= i; j++) {
                int curr = triangle.get(i).get(j);
                if (j == 0) {
                    dp[i][j] = dp[i-1][j] + curr;
                } else if (j == i) {
                    dp[i][j] = dp[i-1][j-1] + curr;
                } else {
                    dp[i][j] = Math.min(dp[i-1][j-1], dp[i-1][j]) + curr;
                }
            }
        }
        int res = dp[triangle.size()-1][0];
        for (int j = 1; j < triangle.size(); j++) {
            res = Math.min(res, dp[triangle.size()-1][j]);
        }
        return res;
    }
}

下面來分析這個問題的時間複雜度以及空間複雜度,一般來說空間複雜度是就是 DP 表格的大小。

在這道問題中是 O(n^2),而對於時間複雜度來說,就是整個 dp 的遍歷次數,而在這個問題中我們只進行了一次遍歷,也即一個矩陣的遍歷,所以是O(n^2)

而如果想要優化到 O(n),我們需要怎麼做呢?

實際上這個就涉及到了一種狀態壓縮的方法,也即壓縮這個狀態表。

那麼怎麼去壓縮呢?

這個問題比較簡單,因為dp[i][j]僅僅與上一層的狀態有關,所以說與前兩層的是沒有任何關係的,因此我們不必儲存這些無關的狀態。

實際上最簡單的狀態壓縮就是保留好前兩個狀態即可,例如在計算第四行的時候,保留第三行以及第二行的狀態表,然後交替的進行更新就可以啦。

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
      // 只保留最近 2 行
        int[][] dp = new int[2][triangle.size()];
        dp[0][0] = triangle.get(0).get(0);
        for (int i = 1; i < triangle.size(); i++) {
            int row = i % 2;
            int prevRow = (i-1) % 2;
            for (int j = 0; j <= i; j++) {
                if (j == 0) {
                    dp[row][j] = dp[prevRow][j] + triangle.get(i).get(j);
                } else if (j == i) {
                    dp[row][j] = dp[prevRow][j-1] + triangle.get(i).get(j);
                } else {
                    dp[row][j] = Math.min(dp[prevRow][j-1], dp[prevRow][j]) + triangle.get(i).get(j);
                }
            }
        }

        int res = dp[(triangle.size() - 1) % 2][0];
        for (int j = 1; j < triangle.size(); j++) {
            res = Math.min(res, dp[(triangle.size() - 1) % 2][j]);
        }
        return res;
    }
}

這個的空間複雜度是 O(2n),能不能壓縮成嚴格意義上的O(n)呢?

那麼再往後是否還能夠進行狀態的壓縮呢?

答案是可以的,我們可以再想一種方程然後達到最優的空間複雜度的目標。

當我們在計算位置 [i][j] 時,f[j+1]f[i] 已經是第 i 行的值,而 f[0]f[j] 仍然是第 i-1 行的值。

此時我們直接通過 f[j] = min(f[j−1], f[j]) + c[i][j]來計算,但是這個時候我們需要j 是倒著遍歷的,因為這樣才不會影響之前記錄下的狀態。

如果從 1 開始,那麼計算 2 的時候就會用到新的 1 的數值而不是上一層 1 的數值。

程式碼如下:

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int[] dp = new int[triangle.size()];
        dp[0] = triangle.get(0).get(0);

        for (int i = 1; i < triangle.size(); i++) {
            dp[i] = dp[i-1] + triangle.get(i).get(i);
            for (int j = i-1; j > 0; j--) {
                dp[j] = Math.min(dp[j-1], dp[j]) + triangle.get(i).get(j);
            }
            dp[0] += triangle.get(i).get(0);
        }

        int res = dp[0];
        for (int j = 1; j < triangle.size(); j++) {
            res = Math.min(res, dp[j]);
        }
        return res;
    }
}

方法 2

方法 1 有點繞,但如果自下向上來理解,就會變得很簡單,這個方法也叫 bottom-up,方法 1 則是 top-down

從結果出發,這個問題是一個發散三角樹的問題,從最後一行出發,然後每一行每一行的進行遞推,那麼第一行就是最終的結果了。

舉個最簡單的例子:

 1
1 2

如果從最底下往上出發,實際上找最小值方法的規律很容易找到,那就是在第二行[1, 2]裡面選擇一個就可以了,因為他們兩個都要走到根節點。

也就是在下一行的兩個數裡面取個小的就行了,那麼結果就是第一行的數值。

我們先用二維的轉移矩陣來解釋這個問題,用這種方法也不需要考慮方法 1 裡面的邊界條件了:
dp[i][j] = min(dp[i+1][j], dp[i+1][j+1]) + c[i][j]

狀態轉換圖如下所示:

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int[][] dp = new int[triangle.size()][triangle.size()];
        // 建立 DP 空間
        for (int i = 0; i < triangle.size(); i++) {
            dp[triangle.size() - 1][i] = triangle.get(triangle.size() - 1).get(i);
        }

        for (int i = triangle.size() - 2; i >= 0; i--) {
            for (int j = 0; j < triangle.get(i).size(); j++) {
                dp[i][j] = Math.min(dp[i+1][j], dp[i+1][j+1]) + triangle.get(i).get(j);
            }
        }

        return dp[0][0];
    }
}

那麼在進行狀態壓縮的時候,我們該怎麼去做呢?

實際上就是隻用一個狀態表來表示所有的。

因為只是和上一個狀態相關,所以說可以表示成如下的形式:

dp[j] = min(dp[j], dp[j + 1]) + triangle[i][j]

我們只用 j 來代表當前的狀態,然後最終輸出dp[0]即可。

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int[] dp = new int[triangle.size()];
        // 建立 DP 空間
        for (int i = 0; i < triangle.size(); i++) {
            dp[i] = triangle.get(triangle.size() - 1).get(i);
        }

        for (int i = triangle.size() - 2; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                dp[j] = Math.min(dp[j], dp[j+1]) + triangle.get(i).get(j);
            }
        }

        return dp[0];
    }
}

總結

以上就是動態規劃解題方法的粗淺介紹,總的來說,我們需要注意動態規劃的這麼幾件事情。

  1. 確定是否需要用動態規劃;
  2. 確定動態規劃的四個部分;
  3. 寫程式碼。

實際上難點就是轉移方程,這個確實需要大量的積累才能夠在面試的時候看穿,甚至有些題沒見過的話就是想不出來的。

但是沒見過就做不出來的題面試一般也不會考,所以大家也不用太擔心,重點還是掌握方法,舉一反三。

接下來我也會歸納總結一些動態規劃的常見題型,和大家一起探索最優解

更多演算法文章,建議收藏這個連結:


我是小齊,後端開發工程師,座標紐約,曾在投行做 Quant,後加入科技公司 FLAG 中的一家。

業餘時間打理公粽號【NYCSDE】,更新略少,乾貨很多,建議加個星標防止錯過。

相關文章