In mathematics and computer science, dynamic programming is a method of solving complex problems by breaking them down into simpler steps. It is applicable to problems that exhibit the properties of overlapping subproblems which are only slightly smaller[1] and optimal substructure (described below). When applicable, the method takes much less time than naive methods.
Top-down dynamic programming simply means storing the results of certain calculations, which are then re-used later because the same calculation is a sub-problem in a larger calculation. Bottom-up dynamic programming involves formulating a complex calculation as a recursive series of simpler calculations。
Intermediate
现在让我们看看如何解决2维DP问题。
问题:
一个拥有N*M个单元的格子,每一个里面都有着一定数量的苹果,数量已经给定。现在你位于左上角。每一步你可以向下走或者向右走。问你能够收集到最多多少个苹果。
这个问题可以向其他DP问题一样来解决;几乎没有差别。首先我们需要找出一个状态。首先我们需要注意到到某个单元里最多有两种方法-要么从它的左边过来(如果当前格子不是在第一列的话),要么从上方过来(如果它不是在最上面的行的话)。为了找到该单元的最优方案,我们首先需要找到到达它的单元的最优方案。从上面的叙述中,我们可以很容易的得到转移关系:
S[i][j]=A[i][j]+max(S[i-1][j],if i>0; S[i][j-1],if j>0) (这里的i代表行,j代表列。左上角的坐标为{0,0};A[i][j]为i,j单元格中的苹果数量)。
S[i][j]需要在每行中从左到右计算,并且从上到下计算每一行,或者从上到下计算每一列然后从左到右处理每一列。
伪代码:
![](http://blog.csdn.net/jtop0/article/details/Images/OutliningIndicators/None.gif)
![](http://blog.csdn.net/jtop0/article/details/Images/OutliningIndicators/None.gif)
![](http://blog.csdn.net/jtop0/article/details/Images/OutliningIndicators/None.gif)
![](http://blog.csdn.net/jtop0/article/details/Images/OutliningIndicators/None.gif)
![](http://blog.csdn.net/jtop0/article/details/Images/OutliningIndicators/None.gif)
![](http://blog.csdn.net/jtop0/article/details/Images/OutliningIndicators/None.gif)
下面是TopCoder比赛中的一些题目,作为练习之用:
- AvoidRoads - 2003 TCO Semifinals 4
- ChessMetric - 2003 TCCC Round 4
Dynamic Programming
程度★★ 難度★★★
Dynamic Programming
中文譯作「動態規劃」,英文常常縮寫成DP。在數學領域中,programming是指「最佳化(optimization)」的意思,例如求極大值、求極小值。dynamic是指「動態」的意思。顧名思義,Dynamic Programming是一個以動態的方式來進行最佳化的方法。
DP = Divide and Conquer + Memoization
DP可視做是Divide and Conquer的延伸版本。當運用Divide and Conquer所遞迴分割出來的子問題都非常相像的時候,並且當同樣的子問題一而再、再而三出現的時候──就運用Memoization儲存全部子問題的答案,節省重複計算相同問題的時間,以空間來換取時間。
![](http://blog.csdn.net/jtop0/article/details/DynamicProgramming1.png)
由於全部子問題的答案都儲存在記憶體的緣故,計算答案的過程,就是反覆不斷地在各塊記憶體中讀取數據、計算數據、儲存數據,動感地達成最佳化──動態規劃之名由此而來。
出現過的子問題會被儲存
DP有一個特點,是當原問題題算好之後,其實也一併將所有出現過的子問題都算好了,其答案都可直接從表格存取。此後當重複提問類似問題時,若提問到的是這些子問題,就可直接從表格取得答案,不需再計算。
子問題可視做狀態,可嘗試建立狀態空間
當子問題之間非常相像的時候,不妨把子問題視作狀態。我們可以嘗試直接建立狀態空間,接下來才來觀察狀態們(子問題們)之間的關係,有助於找出原問題的遞迴分割方式。
時間複雜度、空間複雜度
由於問題的答案都在表格中,記憶體足夠的情況下,存取一個問題的答案通常只需O(1)。如果一個問題可以分成O(d)個子問題(一個問題的答案需要由O(d)個更小的問題計算而得),而全部的子問題共有O(n)個,時間複雜度就是O(n * d * 1)。
空間複雜度則必須以子問題們的出現期間來決定,在計算過程當中,已確定不再出現的子問題,就不必再儲存於表格中,記憶體就可以釋放,或者回收再利用,導致瞬間的記憶體用量不會太多,整體的空間複雜度就會降低。若只是單純的要儲存全部子問題,空間複雜度就是O(n)。
用Dynamic Programming設計演算法時的步驟
1. 利用Divide and Conquer把原問題遞迴地分成許多更小的問題。(recurrence) 甲、子問題與原問題的求解方式皆類似。(optimal sub-structure) 乙、子問題會一而再、再而三的出現。(overlapping sub-problems) 2. 確認每個問題需要哪些子問題來計算答案,並確認總共有哪些子問題。(state space) 3. 決定各個問題的計算先後次序。(computational sequence) 4. 安排好各個問題的答案,要存放在表格的哪個位置。(lookup table) 5. 實做程式,主要有兩種方式: 甲、Top-down, Recursive. 乙、Bottom-up, Iterative.
第一點。先找到原問題和其子問題們之間的關係,寫出遞迴公式。如此一來,便可利用遞迴公式,用子子問題的答案,求出子問題的答案;用子問題的答案,求出原問題的答案。
第二點,確認可能出現的子問題全部共有哪些,這樣才能知道要計算哪些子問題,才能知道共會花多少時間、多少記憶體。
第三點。有了遞迴公式和表格結構之後,就必須安排出一套計算的順序。大問題的答案,總是以小問題的答案來求得的,所以,小問題的答案是必須先算的,否則大問題的答案從何而來呢?
我們會利用較小問題的答案,計算出較大問題的答案──因此,一個好的安排方式,不但會使程式碼容易撰寫,還可有效節省記憶體空間,甚至重複利用記憶體空間。
第四點。實作DP的程式時,會建立一個表格,在表格存入所有大小問題的答案。安排好每個問題的答案在表格的哪個位置,這樣計算時才能知道該在哪裡取值。這個表格其實就是所謂的lookup table。
當撰寫程式碼的時候,應小心下面幾項問題:
初始值:記得先將最小、最先被計算的子問題,將其答案預先算好,內建於程式碼中,並存入表格。一道遞迴公式必須擁有初始值,才有辦法計算其他項。
表格界限:切勿存取超出表格界限的地方。計算過程中,一旦子問題的答案出錯,就會如骨牌效應般一個影響一個,造成很難除錯。
計算順序:切勿存取還沒計算過答案的子問題,原因同前項所述。
第五點。留待下述範例解釋。
一、recurrence
以下以著名的爬樓梯問題來做為範例,其遞迴公式如下:
f(n) = { 1 , if n = 0 { 1 , if n = 1 { f(n-1) + f(n-2) , if n >= 2 註:為了寫作程式方便,遞迴公式中設計了n=0的情形。
為了讓程式碼比較好寫,設計遞迴公式時,可以嘗試在不與原本公式起衝突的情況下,額外增加一些邊界條件。
二、state space
全部的子問題共有六個,從「爬完零階」到「爬完五階」。每個子問題的答案都是由前兩階的答案求得,除了「爬完零階」與「爬完一階」以外。
三、computational sequence
必須最先計算,也是最小的子問題是「爬完零階」與「爬完一階」,它們都是寫程式時就能夠內建答案的子問題。
剩下的子問題,都必須先算好階數少一階、階數少二階這兩個子問題,所以必須由階數較小的子問題開始算。
必須最後計算,也是最大的子問題是原問題「爬完五階」。
整體的計算順序是:「爬完零階」、「爬完一階」、「爬完兩階」、「爬完三階」、「爬完四階」、「爬完五階」。
四、lookup table
可以簡單用一條六格的一維陣列做為lookup table,每一格都對應到一個問題的答案。
- int table[6];
然後設定好最小的子問題的答案,「爬完零階」與「爬完一階」。
- table[0] = 1;
- table[1] = 1;
五、實做程式
直接用遞迴實作,而不使用記憶體儲存各個問題的答案,是最直接的方式,也是最慢的方式。時間複雜度是O(f(n))。有些問題一而再、再而三的出現,不斷呼叫同樣的函式,效率不彰。很多剛接觸DP的新手都會犯這種錯誤。
- int f(int n)
- {
- if (n == 0 || n == 1)
- return 1;
- else
- return f(n-1) + f(n-2);
- }
正確的DP,是一邊計算,一邊將計算出來的數值存入表格當中,以後便不必再重算。這裡整理了兩種實做方式:
1. Top-down, Recursive. 2. Bottom-up, Iterative.
![](http://blog.csdn.net/jtop0/article/details/DynamicProgramming2.png)
這兩種方式各有優缺點,以下說明這兩種方式有何不同。
五之一、Top-down, Recursive
第一種。採用Divide and Conquer的遞迴實作方式,以Divide階段分割原問題,並以Merge階段來計算出原問題的答案。每當計算出一個問題的答案後,就馬上儲存在表格裡面,並記錄該問題已計算。
- int table[6]; // 表格,儲存全部問題的答案。
- bool solve[6]; // 記錄問題是否已計算
- int f(int n)
- {
- if (n == 0 || n == 1)
- return 1;
- if (solve[n])
- return table[n];
- table[n] = f(n-1) + f(n-2); // 將答案存入表格
- solve[n] = true; // 紀錄已計算
- return table[n];
- }
- int main()
- {
- for (int i=0; i<6; i++) solve[i] = false;
- cout << "爬完五階的踏法有" << f(5) << "種";
- return 0;
- }
- // 算完的子問題可以重複利用
- int main()
- {
- for (int i=0; i<6; i++) solve[i] = false;
- for (int n; (cin >> n) && (n >= 0 && n <= 5); )
- cout << "爬完" << n << "階的踏法有" << f(n) << "種";
- return 0;
- }
- int table[6]; // 可以將solve陣列跟table合併,將程式碼簡化。
- int f(int n)
- {
- if (n == 0 || n == 1)
- return 1;
- if (table[n] != 0) // 直接用 0 來代表沒算過
- return table[n];
- return table[n] = f(n-1) + f(n-2);
- }
- int main()
- {
- for (int i=0; i<6; i++) table[i] = 0;
- cout << "爬完五階的踏法有" << f(5) << "種";
- return 0;
- }
- // 算完的子問題可以重複利用
- int main()
- {
- for (int i=0; i<6; i++) table[i] = 0;
- for (int n; (cin >> n) && (n >= 0 && n <= 5); )
- cout << "爬完" << n << "階的踏法有" << f(n) << "種";
- return 0;
- }
這個方式的好處是不必斤斤計較計算順序,因為程式碼中的遞迴結構會迫使最小的子問題先被計算。這個方式的另一個好處是只計算必要的子問題,而不必計算所有可能的子問題(計算整個狀態空間)。
這個方式的壞處是程式碼採用遞迴結構,不斷呼叫函式,執行效率較差。這個方式的另一個壞處是無法自由地控制計算順序,因而無法妥善運用記憶體,浪費了可回收再利用的記憶體。
五之二、Bottom-up, Iterative
第二種。訂定一個計算順序,然後由最小的子問題先計算,其特色是程式碼通常只有幾個迴圈。這個方式的好處與壞處恰與前一個方式互補。
- int table[6];
- // 姑且稱之「往回取值」,較常見的作法。
- int f(int n)
- {
- for (int i=0; i<6; i++) table[i] = 0;
- table[0] = table[1] = 1;
- for (int i = 2; i <= n; i++)
- table[i] = table[i-1] + table[i-2];
- return table[n];
- }
- // 姑且稱之「往後補值」,較少見的作法。
- int f(int n)
- {
- for (int i=0; i<6; i++) table[i] = 0;
- table[0] = 1;
- for (int i = 0; i <= n; i++) {
- if (i+1 <= n) table[i+1] += table[i];
- if (i+2 <= n) table[i+2] += table[i];
- }
- return table[n];
- }
- int main()
- {
- cout << "爬完五階的踏法有" << f(5) << "種";
- return 0;
- }
- // 算完的子問題可以重複利用
- int main()
- {
- f(5);
- for (int n; (cin >> n) && (n >= 0 && n <= 5); )
- cout << "爬完" << n << "階的踏法有" << table[n] << "種";
- return 0;
- }
總結
現在已經有許多問題已經發掘出DP的解法,這些問題通常以遞迴公式和表格結構的樣式,做為主要的分類依據。有賴前人辛苦耕耘,近年來已漸漸整理出幾個經典的題型了。學習這些題型,可以增廣解題的思考方向。大家在學習之餘,也不妨順便開創一些新題型,可供後人學習!這裡列出一些常見的簡易題型,供各位牛刀小試。
UVa 369 485 495 623 10334 10446 10520
Staircase Walk
程度★★ 難度★
Staircase Walk
有一個長方形的方格棋盤,從左上角開始,欲走至右下角,每次只能往右走一格或者往下走一格。請問有幾種不同走法?
這個問題可以很容易的找到遞迴公式。對某個位置的方格來說,只可能是從左走來或者從上走來,將這兩種情形分開,便得到遞迴公式:
c(i, j) = { 0 , if i < 0 or j < 0 { 1 , if i = 0 or j = 0 { c(i-1, j) + c(i, j-1) , if i > 0 and j > 0 c(i, j):從格子 (0, 0) 走到格子 (i, j) 的走法種類數。
除了遞迴公式之外,這個問題也有一般公式解:http://mathworld.wolfram.com/StaircaseWalk.html
時間複雜度分析:令X和Y分別是棋盤的長和寬。每個子問題用O(1)時間(用兩個子問題)就可算得,共有X*Y個子問題,所以算出所有子問題要用O(XY)時間。
空間複雜度分析:共有X*Y個子問題,所以要用O(XY)空間,簡單來說就是開一個二維陣列啦!如果不需要紀錄所有子問題的答案,只想算出其中一個子問題,那只需要一條一維陣列就可以了,也就是O(min(X, Y))空間。
程式碼就不提供囉!各位可以自己試試看!
如果某些格子上有障礙物呢?其實也很簡單,如果某格有障礙物,就把此格的c(i, j)設為零就可以了。
如果也可以往右下斜角走呢?那麼遞迴公式就再修改一下,多加一項c(i-1, j-1)就行了。
如果可以往上下左右走呢?那麼就可以不斷繞圈子,走法就成了無限多種了。寫成遞迴公式的話,就會產生無窮遞迴,永遠也不會結束。
如果也可以往右上斜角走呢?因為不會產生無窮遞迴,所以這是可以解的!
UVa 10599
Maximum Subarray
程度★★ 難度★★
Maximum Subarray
(Maximum Consecutive Sum)
(Maximum Consecutive Subsequence)
問題:從一串數列中取一連串數字求其總和。找出最大的總和。最糟糕的情況就是什麼數字都不取,總和為零。
如果用窮舉法的話,窮舉所有可能的起點、終點,並計算總和,時間複雜度就是O(N^3)。
這是一個非常簡單的問題,只要依序累加數字、做點判斷,就可以找到答案。累加數字求總和就是種Dynamic Programming!
更詳細的資料,可參考「名題精選百則」這本書。現在直接來看程式碼吧。
計算Maximum Subarray之元素總和
- int a[10] = {1, 2, -6, 3, -2, 4, -1, 3, 2, -4};
- int maximum_subarray()
- {
- int max_sum = 0, sum = 0;
- for (int i=0; i<10; ++i)
- {
- sum += a[i]; // 隨時計算總和
- if (sum < 0) sum = 0; // 零總比負數好
- if (sum > max_sum) max_sum = sum; // 隨時紀錄最大值
- }
- return max_sum;
- }
時間複雜度是O(N)。
找出Maximum Subarray的位置
當然也可以找出那串數字。如果有很多串,下面這支程式碼只會找出比較早出現的那一串。
- int a[10] = {1, 2, -6, 3, -2, 4, -1, 3, 2, -4};
- int maximum_subarray()
- {
- int max_sum = 0, sum = 0;
- int start = 0, end = 0, temp_start = 0;
- for (int i=0; i<10; ++i)
- {
- sum += a[i];
- if (sum < 0)
- {
- sum = 0;
- temp_start = i+1; // 現在情況很糟,故設定起點在下一個數字
- }
- if (sum > max_sum)
- {
- max_sum = sum;
- start = temp_start; end=i;
- }
- }
- if (start > end)
- cout << "什麼數字都不取" << endl;
- else
- cout << "從" << start << "到" << end << endl;
- return max_sum;
- }
計算Maximum Subarray之元素總和(至少取一個數字)
- int a[10] = {1, 2, -6, 3, -2, 4, -1, 3, 2, -4};
- int maximum_subarray()
- {
- int max_sum = -1e9, sum = 0;
- for (int i=0; i<10; ++i)
- {
- if (sum > 0) sum += a[i]; // 先前的數字若不為負數才加
- else sum = a[i]; // 不加數字總會比加上負數好
- if (sum > max_sum) max_sum = sum; // 隨時紀錄最大值
- }
- return max_sum;
- }
推廣
這個問題還可推廣到2D、3D。時間複雜度分別是O(N^3)、O(N^5)。以下直接提供3D的情形。
- int A = 20, B = 20, C = 20; // 三個維度的個別寬度
- int a[20][20][20];
- int max1D(int a[])
- {
- int ans = -1e9;
- int b = 0;
- for (int i=0; i<C; ++i)
- {
- if (b >= 0) b += a[i];
- else b = a[i];
- ans = max(ans, b);
- }
- return ans;
- }
- int max2D(int a[][20])
- {
- int ans = -1e9;
- int b[20];
- for (int i=0; i<B; ++i)
- {
- memset(b, 0, sizeof(b));
- for (int j=i; j<B; ++j)
- {
- for (int k=0; k<C; ++k)
- b[k] += a[j][k];
- ans = max(ans, max1D(b));
- }
- }
- return ans;
- }
- int max3D(int a[][20][20])
- {
- int ans = -1e9;
- int b[20][20];
- for (int i=0; i<A; ++i)
- {
- memset(b, 0, sizeof(b));
- for (int j=i; j<A; ++j)
- {
- for (int k=0; k<B; ++k)
- for (int l=0; l<C; ++l)
- b[k][l] += a[j][k][l];
- ans = max(ans, max2D(b));
- }
- }
- return ans;
- }
- int main()
- {
- cout << max3D(a) << endl;
- return 0;
- }
最後,來一點練習題目吧。
UVa 507 10684 108 836 10827 10755
0/1 Knapsack Problem之一
程度★★ 難度★★★
Knapsack Problem
問題:將一群物品儘量塞進背包裡,令背包裡物品總價值最高。僅考慮背包只有負重限制(似乎太天真了一點)。
關於背包問題,世界上已經有很多研究成果了。這裡向大家提供一本專述背包問題的論著,作者精心整理了背包問題的相關問題和研究成果,並免費提供電子檔給大家,大家請記得要滿懷感激的看此書:http://www.or.deis.unibo.it/knapsack.html。
UVa 233 10898
0/1 Knapsack Problem
背包問題是很經典的問題,亦引申出許多變形和應用。這裡我們只介紹最基本易懂的其中一種變形:0/1 knapsack problem。
文言的說法是:每種類型的物品只會放進背包零個或一個。通俗的說法是:每個物品都是不同類型的,每種物品都只有一個。
這個問題原本是個NP-Complete問題。當數值範圍不大時,能以DP處理之。
分割問題的方法
當我們把一件物品放進背包裡時,會讓總價值變高,並且讓背包變重。對某一件物品來說,我們可以選擇放或不放;然後移去這件物品所帶來的影響,將問題縮小成子問題。遞迴式便可設計為:
c(n, w) = max( c(n-1, w), c(n-1, w-W[n]) + C[n] ) ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ 不放 -> 0 放 -> 1 n:第1個到第n個物品要放進背包內。 w:背包負重上限。 c(n, w):第1個到第n個物品儘量塞入負重限制為w的背包時,其總價值的最大值。 W[n]:第n個物品的重量。 C[n]:第n個物品的價值。
考慮一下東西放不進去時的情形,以及沒有東西時的情形。
c(n, w) = { 0 , if n = 0 and w >= 0 { max( c(n-1, w), c(n-1, w-W[n]) + C[n] ) , if n > 0 and w-W[n] >= 0 { c(n-1, w) , if n > 0 and w-W[n] < 0
物品一開始的先後順序是無所謂的,最後得出的答案都會一樣。
計算出背包裡物品總價值的最大值(Bottom-up)
只要計算所有小問題,那麼大問題的答案必然可以推得出來。建立二維表格後,依序計算每個小問題吧!
- // 物品總數上限。
- const int MaxN = 100;
- // 背包負重上限。有時也會利用所有物品的總重量作為此值。
- const int MaxW = 100000;
- // 物品的價值與重量。
- int C[MaxN], W[MaxN];
- // DP所需的陣列,需初始化為零。
- int c[MaxN + 1][MaxW + 1];
- void knapsack(int n, int w) // n 為物品個數,w 為背包負重上限
- {
- memset(c, 0, sizeof(c)); // 初始化為零
- for (int i = 0; i < n; ++i) // 每個物品都試試看
- for (int j = 0; j <= w; ++j) // 每個重量都試試看
- if (j - W[i] < 0)
- c[i+1][j] = c[i][j]; // 負重能力不足,故只能不放
- else
- c[i+1][j] = max( c[i][j], c[i][j - W[i]] + C[i] );
- cout << "最高的價值為" << c[n][w] << endl;
- }
因為計算時只需要用到上方和左上方的格子,所以其實只需要一條陣列就夠了。不過計算次序需要改為由陣列後端開始,才不會覆蓋掉需要拿來計算的陣列格子。
- const int MaxN = 100, MaxW = 100000;
- int C[MaxN], W[MaxN];
- int c[MaxW + 1]; // 只需要一條陣列就夠了
- void knapsack(int n, int w) // n 為物品個數,w 為背包負重上限
- {
- memset(c, 0, sizeof(c)); // 初始化為零
- for (int i = 0; i < n; ++i)
- for (int j = w; j - W[i] >= 0; --j) // 由後往前
- c[j] = max( c[j], c[j - W[i]] + C[i] );
- cout << "最高的價值為" << c[w] << endl;
- }
程式碼也可以寫成這樣,讓人容易理解。
- const int MaxN = 100, MaxW = 100000;
- struct Item {int cost, weight;} items[MaxN]; // 設計成物件
- int c[MaxW + 1];
- void knapsack(int n, int w)
- {
- memset(c, 0, sizeof(c));
- for (int i = 0; i < n; ++i)
- {
- int weight = items[i].weight, cost = items[i].cost;
- for (int j = w; j - weight >= 0; --j)
- c[j] = max( c[j], c[j - weight] + cost );
- }
- cout << "最高的價值為" << c[w] << endl;
- }
計算出背包裡物品總價值的最大值(Top-down)
方才所採用的方法會計算到所有可能的小問題,然而並不是所有小問題都需要計算,故採用Top-down的方式會比較快。
- const int MaxN = 100;
- const int MaxW = 100000;
- int C[MaxN], W[MaxN];
- int c[MaxN + 1][MaxW + 1];
- int knapsack(int n, int w) // n 為物品個數,w 為背包負重上限
- {
- if (w < 0) return -1e9; // 負重能力不足,故只能不放
- if (n == 0) return 0; // 沒有物品時,就沒有cost
- if (c[n][w]) return c[n][w]; // memoization,直接讀取記憶體的答案
- return c[n][w] =
- max(knapsack(n-1, w-W[n]) + C[n], knapsack(n-1, w));
- }
找出此時背包裡最多可剩下多少空間、最少只用了多少空間
從表格的右方開始往左搜尋即可。當發現最佳的cost將要變小時,表示該處為最節省空間的地方。然而這不是很好的作法。
- const int MaxN = 100, MaxW = 100000;
- int C[MaxN], W[MaxN];
- int c[MaxW + 1];
- void knapsack(int n, int w)
- {
- memset(c, 0, sizeof(c));
- for (int i = 0; i < n; ++i)
- for (int j = w; j - W[i] >= 0; --j)
- c[j] = max( c[j], c[j - W[i]] + C[i] );
- cout << "最高的價值為" << c[w] << endl;
- while (w-1 >= 0 && c[w-1] == c[w]) w--; // 往左搜尋邊界
- cout << "使用的空間最少可為" << w << endl;
- }
找出此時背包裡放了哪些物品
另外再建立一個二維陣列,紀錄每一格的數值是由哪個子問題所算得的。每個問題只會有放或不放兩種情形,所以只要記錄放或不放便可以了。這段程式碼只能找出其中一種配置物品的方式。
這裡要注意的是,由於尋找放入的物品時必須要從表格的右下角逆推,如此得到的物品順序並不會是字典順序最小的一組。因此下面的程式碼會將所有物品依照相反順序進行DP的計算,然後再逆推、求放入的物品時,就會剛好是字典順序了。
- const int MaxN = 100, MaxW = 100000;
- int C[MaxN], W[MaxN];
- int c[MaxW + 1];
- bool path[MaxN][MaxW + 1]; // 紀錄放還是不放,false為不放,true為放
- void knapsack(int n, int w)
- {
- memset(c, 0, sizeof(c));
- memset(path, 0, sizof(path)); // 初始化為 false
- for (int i = n-1; i >= 0; --i) // 改為由後往前
- for (int j = w; j >= W[i]; --j)
- if (c[j - W[i]] + C[i] > c[j])
- {
- c[j] = c[j - W[i]] + C[i];
- path[i][j] = true; // 放入
- }
- cout << "最高的價值為" << c[w] << endl;
- for (int i = 0, j = w; i < N; ++i) // 往回逆推,求放入的物品。
- if (path[i][j]) // 背包有該物品
- {
- cout << "背包裡有第" << i << "個物品" << endl;
- j -= W[i];
- }
- }
找出所有的配置物品的方式
方才的程式碼只能找出一種配置背包內物品的方式。若要找出所有方式,那就要寫個遞迴了吧?就我所知,目前尚未存在有效率的方法,能夠求出所有的配置方式。
- const int MaxN = 100, MaxW = 100000;
- int C[10], W[10];
- int c[MaxW + 1];
- int path[MaxN][MaxW + 1]; // 0為不放,1為放,2為可放可不放
- void knapsack(int n, int w)
- {
- memset(c, 0, sizeof(c));
- memset(path, 0, sizof(path));
- for (int i = n-1; i >= 0; --i)
- for (int j = w; j >= W[i]; --j)
- if (c[j - W[i]] + C[i] > c[j]) // 放了會比較好
- {
- c[j] = c[j - W[i]] + C[i];
- path[i][j] = 1;
- }
- else if (c[j - W[i]] + C[i] == c[j]) // 可放可不放
- {
- path[i][j] = 2;
- }
- else if (c[j - W[j]] + C[i] < c[j]) // 不放比較好
- {
- // c[j] = c[j];
- path[i][j] = 0;
- }
- cout << "最高的價值為" << c[w] << endl;
- }
- // 從表格右下角開始往回逆推
- void find_path(int n, int w)
- {
- if (n < 0) return; // 找完了
- if (path[n][w] == 1) // 背包有該物品
- {
- cout << "背包裡有第" << i << "個物品" << endl;
- find_path(n-1, w-W[i]);
- }
- else if (path[n][w] == 2) // 可有可無
- {
- cout << "背包裡有第" << i << "個物品" << endl;
- find_path(n-1, w-W[i]);
- find_path(n-1, w);
- }
- else if (path[n][w] == 0) // 背包沒有該物品
- {
- find_path(n-1, w);
- }
- }
塞入最少個物品、最多個物品
若只是要找出物品塞最少個或最多個的配置方式,則可以重新設計recurrence為:
c(n, w, t) = max( c(n-1, w-W[n], t-1) + C[n] , c(n-1, w, t) ) t:放入的物品個數。
建立三維的表格,並算出每一格的答案後,接著窮舉所有可能的t,觀察那些格子、相互比較cost之後,便可以得到最佳解。程式碼就不寫了。
Greedy
當每個物品的重量相互之間皆為倍數關係,優先放入價值與重量比值較高的物品,可以讓總價值最高。但是我不確定是不是一定要呈倍數關係,才能有greedy演算法。(可參考本站文件「Dynamic Programming─Money Changing Problem」的Change-Making Problem: Cashier's Algorithm章節)
計算出背包裡物品總價值的最小值
剛剛所討論是讓背包裡物品總價值最高的方法;至於要讓背包裡物品總價值最低的話,那就是什麼東西都不要放進背包了吧。
整理了一些類題。
UVa 431 624 990 10130 10819
0/1 Knapsack Problem之二
程度★★ 難度★
另一種分割問題的方法
想像物品放入背包時是照物品編號順序來放。由於每一種物品都可能是最後一個放入背包的物品,遞迴式可設計為:
c(n, w) = max( 0, 都不放 c(0, w-W[0]) + C[0], 最後是放第1個物品(index 0) c(1, w-W[1]) + C[1], 最後是放第2個物品(index 1) ... , ... c(n-1, w-W[n-1]) + C[n-1] ) 最後是放第n個物品(index n-1) n:第1個到第n個物品要放進背包內。 w:背包負重上限。 c(n, w):n個物品儘量塞入負重限制為w的背包時,其總價值的最大值。 W[n]:第n個物品的重量。 C[n]:第n個物品的價值。
計算出背包裡物品總價值的最大值(Top-down)
隨意寫一下。如果寫錯要跟我講呀。
- // 物品的價值、重量,以及DP會用到的表格。
- int C[100], W[100], c[100 + 1][100000 + 1];
- int knapsack(int n, int w) // n 為物品個數,w 為背包負重上限
- {
- if (w < 0) return -1e9; // 負重能力不足,故只能不放
- if (n == 0) return 0; // 沒有物品時,就沒有cost
- if (c[n][w]) return c[n][w]; // memoization,直接讀取記憶體的答案
- int v = 0;
- for (i=0; i<n; ++i) // 每個物品都試試看
- v = max(v, knapsack(i, w-W[i]) + C[i]);
- return c[n][w] = v;
- }
Matrix Chain Multiplication
程度★★ 難度★
Matrix Chain Multiplication
矩陣乘法具有結合率。在一連串的矩陣乘法中,可以從中任取兩個相鄰的矩陣相乘,先行結合成一個新矩陣,也不會改變所有矩陣相乘之後的結果。
在一連串的矩陣乘法中,無論從何處開始相乘其結果都不變,然而計算速度卻有差異。兩個矩陣大小為a x b及b x c,其相乘需要O(a*b*c)的時間(當然還可以更快,但此處不討論),那麼一連串的矩陣乘法,需要多少時間呢?
分割問題的方法
這個問題在許多地方都找得到資料,故只略述。從最後一次相乘的角度來看,原來的一連串矩陣,可從最後一次相乘的地方分開,便能將原問題化作兩串矩陣相乘,然後再合併起來。分割問題的方法類似於本站文件「Divide and Conquer─Fast Exponentiation」,但在本問題中,並非固定地對半分,而是同時考慮所有可能的分法。
當然也可以印出矩陣相乘的順序。只要另外再用一個陣列來紀錄每次相乘的位置就行了。
另一種方法
現今已能在O(NlogN)時間內解決Matrix Chain Multiplication,是我從網路論壇上聽聞到的:http://historical.ncstrl.org/litesite-data/stan/CS-TR-81-875.pdf。
UVa 348 442
Optimal Binary Search Tree
程度★★ 難度★★
Optimal Binary Search Tree
問題說明:略!總之就是所有鍵值的「深度」乘上「權重(出現頻率)」的總和要最小。
![](http://blog.csdn.net/jtop0/article/details/OptimalBinarySearchTree.jpg)
Optimal Binary Search Tree的相似產物
這裡整理了三種很相像的樹,都是令所有鍵值的「深度」乘上「權重(出現頻率)」的總和最小。
Optimal Binary Search Tree:樹上所有點都是鍵值,且鍵值須照大小順序安排。可用Dynamic Programming解決,時間複雜度為O(N^3),可優化至O(N^2)。
Optimal Alphabetic Binary Code Tree:只有葉子是鍵值,且鍵值前後順序需固定。可用Greedy解決,時間複雜度為O(NlogN)。
Optimal Binary Code Tree(Huffman Tree):只有葉子是鍵值,且鍵值順序隨意。可用Greedy解決,時間複雜度為O(NlogN)。
分割問題的方法
和Matrix Chain Multiplication相同,窮舉所有可以當作root的鍵值,並以root將原來的樹分作左右兩棵子樹,便縮小了問題。
實作
下面的程式碼將陣列邊界左右各加一格,如此可省去一些判斷陣列邊界的麻煩。
- // 鍵值排序後,各自對應的出現頻率。最左邊和最右邊是額外加上的空格子。
- int freq[5+2] = {0, 4, 6, 12, 2, 5, 0};
- int sum[5+2][5+2]; // 連續區間和
- int c[5+2][5+2]; // 實行DP所用的陣列。初始化為零。
- int path[5+2][5+2]; // 用來紀錄左右子樹的分割點
- void OptimalBinarySearchTree()
- {
- /* 先計算連續區間和。之後就會輕鬆多了。 */
- for (int i=0; i<5; ++i) // 區間的寬度
- for (int j=1; j+i<=5; ++j) // 區間的起點
- sum[j][j+i] = freq[j] + sum[j+1][j+i];
- /* 計算最佳的二元搜尋樹。 */
- for (int i=0; i<5; ++i) // 區間的寬度
- for (int j=1; j+i<=5; ++j) // 區間的起點
- {
- int c[j][j+i] = 1e9;
- for (int k=j; k<=j+i; ++k) // 分割點
- if (c[j][k-1] + c[k+1][j+i] + sum[j][j+i] < c[j][j+i])
- {
- c[j][j+i] = c[j][k-1] + c[k+1][j+i] + sum[j][j+i];
- path[j][j+i] = k;
- }
- }
- cout << "最佳的二元搜尋樹的平均搜尋成本為" << c[1][5];
- }
由於第二層迴圈實行時,sum[j][j+i]都維持定值,也不影響最大值的判斷,故可將之移到迴圈外面去。加法次數減少,會稍微快一點。
- for (int j=1; j+i<=5; ++j)
- {
- int c[j][j+i] = 1e9;
- for (int k=j; k<=j+i; ++k)
- if (c[j][k-1] + c[k+1][j+i] < c[j][j+i])
- {
- c[j][j+i] = c[j][k-1] + c[k+1][j+i]; // 移走
- path[j][j+i] = k;
- }
- c[j][j+i] += sum[j][j+i]; // 移到這裡來
- }
迴圈判斷式中,關於區間起點的範圍,與其用減法計算區點起點的界限,不如簡單想成區間終點不超過陣列邊界。
- for (int i=0; i<5; ++i) // 區間的寬度
- for (int j=1; j<=5-i; ++j) // 用減法計算區間起點的界限
- // 不確定j+i會不會超過邊界
- sum[j][j+i] = freq[j] + sum[j+1][j+i];
- for (int i=0; i<5; ++i)
- for (int j=1; j+i<=5; ++j) // 區間終點不超過陣列邊界
- // 對應到此處的index,可確定j+i不會超過陣列邊界。
- sum[j][j+i] = freq[j] + sum[j+1][j+i];
印出Optimal Binary Search Tree
嗯哼。為了不剝奪各位寫程式的樂趣,所以這裡就不提了。
時間複雜度
所有的子問題共有O(N^2)個,每個子問題需要窮舉O(N)種分割點,故時間複雜度為O(N^3)。
優化
當recurrence具有特殊的遞增或遞減性質時,便可有辦法加速。【待補凸四邊形不等式】
每次計算一個子問題時,總是要窮舉所有的分割點。然而有些分割點很明顯地是錯誤的,尤其是靠近區間邊界的那些分割點,實在不太可能將兩顆子樹分的夠均勻、令總和最小。
另外這個問題還有一個特性。相近的子問題,其分割點的位置也很相近。例如子問題[a,b]的分割點,應該會與子問題[a-1,b]、[a+1,b]的分割點差不多,因為分割出來的左右子樹頂多也只差了一個鍵值,考量到左右子樹要均勻才行,可推論總成本、子樹的形狀、分割點的位置應該都是差不多的。
事實上,細心的觀察者們,可以發現子問題[a,b]的分割點,必定位於更小的子問題[a+1,b]和[a,b-1]的分割點之間。如此一來,每次計算一個子問題時,就不必窮舉所有的分割點,只要找更小的子問題[a+1,b]和[a,b-1]的分割點之間的分割點即可,為常數個(請各位自行觀察一下)。
由於檢查分割點的次數變成常數次,所以時間複雜度為O(1)。計算O(N^2)個子問題時,時間複雜度就是O(N^2)了。
- for (int k=path[j+1][j+i]; k<=path[j][j+i-1]; ++k) // 分割點
UVa 10304
Bitmask in Dynamic Programming問題特輯
程度★★ 難度★★
Bitmask
bitmask是一串二進位數字,每一個位元分別代表一件東西,1代表開啟,0代表關閉。例如現在有十個燈泡,編號設定為零到九,其中第零個、第一個、第四個、第八個燈泡是亮的,剩下來的燈泡是暗的,我們可以用一個10 bit的二進位數字0100001001,來表示這十個燈泡現在的亮暗狀態。
如果想替各種狀態做進一步的記錄,我們可以建立一個大小為2^10的陣列,便囊括了所有可能的狀態。這個陣列的每一格,就代表一種燈泡開關的狀態,可以進行記錄。
- int array[1<<10];
- array[521] = 想記錄的數字;
- /* 100001001(2進位) = 521(10進位) */
Maximum Cardinality Matching
大意:給一張圖,相鄰的兩點可匹配在一起,求這張圖的最大匹配方式及匹配數目。
此題有多項式時間的解法,不過很難實作。用DP雖然慢了些,但簡單多了,只要把一對匹配在一起的點拿掉,就可以得到遞迴公式:
c[s] = max ( c[s-{i}-{j}] + adj[i,j] ) c[s+{i}+{j}] = max ( c[s] + adj[i,j] ) i、j:點。 s:點集合。 c[s]:s當中的點,所構成的最大匹配數。 adj[i,j]:adjacency matrix。邊ij暢通就是1,不暢通就是0。
實作時,可利用bitmask做為s的資料結構,匹配過的點都標成1,未匹配的點都標成0。
這個方法的時間複雜度為O(2^N * N^2),空間複雜度為O(2^N)。
這個方法需要大量記憶體,所以無法計算N很大的情況,何況編譯器也不准我們開太大的陣列,N=28就是極限了。這個方法同時也需要大量時間,以現在的個人電腦來說,N=17就已經要花上幾分鐘才能求出答案了。
- // top-down DP
- const int N = 10; // 點的數目
- int dp[1<<N]; // lookup table for memoization
- bool ok[1<<N]; // 記錄lookup table是否已存值
- int adj[N][N]; // adjacency matrix。暢通為1,否則為0。
- bool MCM(int s)
- {
- if (s == 0) return true;
- if (ok[s]) return dp[s];
- for (int i=0; i<N; ++i)
- for (int j=i+1; j<N; ++j)
- if (s & ((1<<i) | (1<<j)))
- {
- // ss = s - {i} - {j};
- int ss = s ^ (1<<i) ^ (1<<j);
- dp[s] >?= MCM(ss) + adj[i][j];
- }
- ok[s] = true;
- return dp[s];
- }
- int MCM()
- {
- memset(dp, 0, sizeof(dp));
- memset(ok, false, sizeof(ok));
- return MCM((1<<N)-1);
- }
這個演算法可以再修正,讓時間複雜度成為O(2^N * N),各位可以試試看。
Minimum Weight Matching / Maximum Weight Matching
大意:給一張圖,相鄰的兩點可匹配在一起,求這張圖的所有最大匹配當中,權重最小(大)的匹配方式及權重。
此題亦有多項式時間的解法,但是很難實作。DP解法同前,稍微改一下遞迴公式的運算符號就行了。程式碼就不寫了。
w[s] = min ( w[s-{i}-{j}] + adj[i,j] ) w[s+{i}+{j}] = min ( w[s] + adj[i,j] ) i、j:點。 s:點集合。 w[s]:s當中的點,所構成的最大匹配的最小權重。 adj[i,j]:adjacency matrix。邊ij的權重。
UVa 10888 10911 11439
Chinese Postman Problem(CPP)
大意:給定一張圖,郵差想走過圖上每一條邊去寄信,最後回到原點。求最短的走法及長度。
此題會用到Minimum Weight Matching,故在此列出。此題不論是無向圖或是有向圖,都有多項式時間的解法,可是很難實作。
UVa 10296 11156
判斷一張圖上存不存在Hamilton Path
大意:是否存在一條通過圖上所有點的路徑,若有則找出走法。
此題目前無多項式時間的解法。最容易的解法是使用backtracking,窮舉圖上所有點的各種排列方式,一種排列方式當作是一條路徑,並判斷該路徑是不是Hamilton Path。
把一條路徑的最後一條邊拆掉的話,就可以形成遞迴公式。注意到路徑的端點,當端點不同,結果會不同,所以需要另外一個維度來記錄路徑的端點:
path[s,j] = or_all ( path[s-{j},i] && adj[i,j] ) path[s+{j},j] = or_all ( path[s,i] && adj[i,j] ) i、j:點。 s:點集合。 path[s,j]:經過s當中所有點且最後一點是j的路徑,如果暢通就是true,不暢通就是false。 adj[i,j]:adjacency matrix。邊ij暢通就是true,不暢通就是false。
- // top-down DP
- const int N = 10; // 點的數目
- bool dp[1<<N][N]; // lookup table for memoization
- bool ok[1<<N][N]; // 記錄lookup table是否已存值
- bool adj[N][N]; // adjacency matrix。暢通為true,否則為false。
- bool path(int s, int j, int s_size)
- {
- if (s_size == 1) return true; // s只有一個位元是1
- if (ok[s][j]) return dp[s][j];
- for (int i=0; i<N; ++i)
- if (i != j && s & (1 << i))
- dp[s][j] ||= (path(s ^ (1 << j), i, s_size - 1) && adj[i][j]);
- ok[s][j] = true;
- return dp[s][j];
- }
- bool Hamilton_Path()
- {
- memset(dp, false, sizeof(dp));
- memset(ok, false, sizeof(ok));
- for (int i=0; i<N; ++i)
- if (path((1<<N)-1, i, N))
- return true;
- return false;
- }
計算一張圖的Hamilton Path的數量
解法同前,稍微改一下遞迴公式的運算符號就行了。程式碼就不寫了。
c[s,j] = sigma ( c[s-{j},i] * adj[i,j] ) c[s+{j},j] = sigma ( c[s,i] * adj[i,j] ) i、j:點。 s:點集合。 c[s,j]:經過s當中所有點且最後一點是j的路徑數量。 adj[i,j]:adjacency matrix。邊ij暢通就是1,不暢通就是0。
Travelling Salesman Problem(TSP)
TSP是一個經典的NP-Complete問題。大意是:一個周遊各國的商人,他想去所有不同的城市買賣東西。商人為了節省車馬費,打算從其中一個城市出發,各個地方剛好經過一次之後,回到原城市。所有城市之間都有路,請規劃出距離最短的路線,以及算出距離。這個問題其實也就是找一個權重最小的Hamilton Circuit。
解法同前,稍微改一下遞迴公式運算符號就行了:
dist[s,j] = min ( dist[s-{j},i] + adj[i,j] ) dist[s+{j},j] = min ( dist[s,i] + adj[i,j] ) i、j:點。 s:點集合。 dist[s,j]:經過s當中所有點且最後一點是j的路徑長度。 adj[i,j]:adjacency matrix。邊ij的長度。
上面的遞迴公式只能求出權重最小的Hamilton Path。在TSP當中,不管從哪一點出發,求出來的答案都一樣,反正都會繞一圈經過每個點,所以我們令商人從第0點出發,當找到一條Hamilton Path之後,再額外加上一條回到第0點的邊,就能產生一個Hamilton Circuit了。
- // fake bottom-up DP,同樣的子問題可能會算許多遍。
- int dp[1<<N][N]; // lookup table for memoization
- int adj[N][N]; // adjacency matrix。兩點間的距離。
- int ans; // TSP的答案
- void TSP(int s. int i, int s_size)
- {
- if (s_size == N)
- {
- // 最後再加上一條回到原點的邊,形成環狀路線。
- if (dp[s][i] + adj[i][0] < ans)
- ans = dp[s][i] + adj[i][0];
- return;
- }
- for (int j=1; j<N; ++j) // 只走第0點以外的點
- if (!(s & (1 << j)))
- {
- // ss = s + {j};
- int ss = s | (1 << j);
- if (!dp[ss][j] || dp[s][i] + adj[i][j] < dp[ss][j])
- {
- dp[ss][j] = dp[s][i] + adj[i][j];
- TSP(ss, j, s_size + 1);
- }
- }
- }
- void TSP()
- {
- memset(dp, 0, sizeof(dp));
- ans = 1e9;
- TSP(0, 0, 0); // 令商人從第0點出發。
- cout << ans << endl;
- }
另外這裡再附上一個不正確的程式碼。表格的用途是這樣的:dp[目前走過的地點數][已走過的地點]。這個方法會在計算dp[N][N個1組成的二進位數字]的時候產生錯誤(N為地點數目)。
- void TSP(int d, int now, int mask)
- {
- if (d == N)
- {
- if (dp[d][mask] + dd(now, 0) < ans)
- ans = dp[d][mask] + dd(now, 0);
- return;
- }
- for (int i=1, mm=1; i<=N; ++i, mm<<=1)
- if (!(mask & mm))
- if (!dp[d+1][mask | mm] || dp[d][mask] + dd(now, i) < dp[d+1][mask | mm])
- {
- dp[d+1][mask | mm] = dp[d][mask] + dd(now, i);
- TSP(d+1, i, mask | mm);
- }
- }
UVa 216 10068 10496 10818 10937 10944 10605 10890
Subset Sum Problem / Partition Problem
參照Money Changing Problem之湊得某個價位的錢幣用量有哪幾種
http://www.cnblogs.com/drizzlecrj/archive/2007/10/26/939159.html