非常有必要看一看：

一、基本概念

    動態規劃過程是：每次決策依賴於當前狀態，又隨即引起狀態的轉移。一個決策序列就是在變化的狀態中產生出來的，所以，這種多階段最優化決策解決問題的過程就稱為動態規劃。

二、基本思想與策略

    基本思想與分治法類似，也是將待求解的問題分解為若干個子問題（階段），按順序求解子階段，前一子問題的解，為後一子問題的求解提供了有用的資訊。在求解任一子問題時，列出各種可能的區域性解，通過決策保留那些有可能達到最優的區域性解，丟棄其他區域性解。依次解決各子問題，最後一個子問題就是初始問題的解。

    由於動態規劃解決的問題多數有重疊子問題這個特點，為減少重複計算，對每一個子問題只解一次，將其不同階段的不同狀態儲存在一個二維陣列中。

    與分治法最大的差別是：適合於用動態規劃法求解的問題，經分解後得到的子問題往往不是互相獨立的（即下一個子階段的求解是建立在上一個子階段的解的基礎上，進行進一步的求解）。

三、適用的情況

能採用動態規劃求解的問題的一般要具有3個性質：

    (1) 最優化原理：如果問題的最優解所包含的子問題的解也是最優的，就稱該問題具有最優子結構，即滿足最優化原理。

    (2) 無後效性：即某階段狀態一旦確定，就不受這個狀態以後決策的影響。也就是說，某狀態以後的過程不會影響以前的狀態，只與當前狀態有關。

   （3）有重疊子問題：即子問題之間是不獨立的，一個子問題在下一階段決策中可能被多次使用到。（該性質並不是動態規劃適用的必要條件，但是如果沒有這條性質，動態規劃演算法同其他演算法相比就不具備優勢

四、求解的基本步驟

     動態規劃所處理的問題是一個多階段決策問題，一般由初始狀態開始，通過對中間階段決策的選擇，達到結束狀態。這些決策形成了一個決策序列，同時確定了完成整個過程的一條活動路線(通常是求最優的活動路線)。如圖所示。動態規劃的設計都有著一定的模式，一般要經歷以下幾個步驟。

    初始狀態→│決策１│→│決策２│→…→│決策ｎ│→結束狀態

圖1 動態規劃決策過程示意圖

    (1)劃分階段：按照問題的時間或空間特徵，把問題分為若干個階段。在劃分階段時，注意劃分後的階段一定要是有序的或者是可排序的，否則問題就無法求解。

    (2)確定狀態和狀態變數：將問題發展到各個階段時所處於的各種客觀情況用不同的狀態表示出來。當然，狀態的選擇要滿足無後效性。

    (3)確定決策並寫出狀態轉移方程：因為決策和狀態轉移有著天然的聯絡，狀態轉移就是根據上一階段的狀態和決策來匯出本階段的狀態。所以如果確定了決策，狀態轉移方程也就可寫出。但事實上常常是反過來做，根據相鄰兩個階段的狀態之間的關係來確定決策方法和狀態轉移方程。

    (4)尋找邊界條件：給出的狀態轉移方程是一個遞推式，需要一個遞推的終止條件或邊界條件。

    一般，只要解決問題的階段、狀態和狀態轉移決策確定了，就可以寫出狀態轉移方程（包括邊界條件）。

實際應用中可以按以下幾個簡化的步驟進行設計：

    （1）分析最優解的性質，並刻畫其結構特徵。

    （2）遞迴的定義最優解。

    （3）以自底向上或自頂向下的記憶化方式（備忘錄法）計算出最優值。

    （4）根據計算最優值時得到的資訊，構造問題的最優解。

五、演算法實現的說明

    動態規劃的主要難點在於理論上的設計，也就是上面4個步驟的確定，一旦設計完成，實現部分就會非常簡單。

     使用動態規劃求解問題，最重要的就是確定動態規劃三要素：

    （1）問題的階段 

    （2）每個階段的狀態

    （3）從前一個階段轉化到後一個階段之間的遞推關係。

     遞推關係必須是從次小的問題開始到較大的問題之間的轉化，從這個角度來說，動態規劃往往可以用遞迴程式來實現，不過因為遞推可以充分利用前面儲存的子問題的解來減少重複計算，所以對於大規模問題來說，有遞迴不可比擬的優勢，這也是動態規劃演算法的核心之處。

    確定了動態規劃的這三要素，整個求解過程就可以用一個最優決策表來描述，最優決策表是一個二維表，其中行表示決策的階段，列表示問題狀態，表格需要填寫的資料一般對應此問題的在某個階段某個狀態下的最優值（如最短路徑，最長公共子序列，最大價值等），填表的過程就是根據遞推關係，從1行1列開始，以行或者列優先的順序，依次填寫表格，最後根據整個表格的資料通過簡單的取捨或者運算求得問題的最優解。

          f(n,m)=max{f(n-1,m), f(n-1,m-w[n])+P(n,m)}

六、動態規劃演算法基本框架

程式碼

  首先，我們看一下這道題（此題目來源於北大POJ）：

    數字三角形(POJ1163)

在上面的數字三角形中尋找一條從頂部到底邊的路徑，使得路徑上所經過的數字之和最大。路徑上的每一步都只能往左下或 右下走。只需要求出這個最大和即可，不必給出具體路徑。 三角形的行數大於1小於等於100，數字為 0 - 99

    輸入格式：

    5      //表示三角形的行數    接下來輸入三角形

    7

    3   8

    8   1   0

    2   7   4   4

    4   5   2   6   5

    要求輸出最大和

    接下來，我們來分析一下解題思路：

    首先，肯定得用二維陣列來存放數字三角形

    然後我們用D( r, j) 來表示第r行第 j 個數字(r,j從1開始算)

    我們用MaxSum(r, j)表示從D(r,j)到底邊的各條路徑中，最佳路徑的數字之和。

    因此，此題的最終問題就變成了求 MaxSum(1,1)

    當我們看到這個題目的時候，首先想到的就是可以用簡單的遞迴來解題：

    D(r, j)出發，下一步只能走D(r+1,j)或者D(r+1, j+1)。故對於N行的三角形，我們可以寫出如下的遞迴式：   

1. if ( r == N)                  
2.     MaxSum(r,j) = D(r,j)    
3. else
4.     MaxSum( r, j) = Max{ MaxSum(r＋1,j), MaxSum(r+1,j+1) } + D(r,j)   

    根據上面這個簡單的遞迴式，我們就可以很輕鬆地寫出完整的遞迴程式碼： 

1. #include <iostream>  
2. #include <algorithm> 
3. #define MAX 101  
4. usingnamespace std;   
5. int D[MAX][MAX];    
6. int n;    
7. int MaxSum(int i, int j){      
8.     if(i==n)    
9.         return D[i][j];      
10.     int x = MaxSum(i+1,j);      
11.     int y = MaxSum(i+1,j+1);      
12.     return max(x,y)+D[i][j];    
13. }  
14. int main(){      
15.     int i,j;      
16.     cin >> n;      
17.     for(i=1;i<=n;i++)     
18.         for(j=1;j<=i;j++)          
19.             cin >> D[i][j];      
20.     cout << MaxSum(1,1) << endl;    
21. }        

    對於如上這段遞迴的程式碼，當我提交到POJ時，會顯示如下結果：

    對的，程式碼執行超時了，為什麼會超時呢？

    答案很簡單，因為我們重複計算了，當我們在進行遞迴時，計算機幫我們計算的過程如下圖：

    就拿第三行數字1來說，當我們計算從第2行的數字3開始的MaxSum時會計算出從1開始的MaxSum，當我們計算從第二行的數字8開始的MaxSum的時候又會計算一次從1開始的MaxSum，也就是說有重複計算。這樣就浪費了大量的時間。也就是說如果採用遞規的方法，深度遍歷每條路徑，存在大量重複計算。則時間複雜度為 2的n次方,對於 n = 100 行，肯定超時。 

    接下來，我們就要考慮如何進行改進，我們自然而然就可以想到如果每算出一個MaxSum(r,j)就儲存起來，下次用到其值的時候直接取用，則可免去重複計算。那麼可以用n方的時間複雜度完成計算。因為三角形的數字總數是 n(n+1)/2

    根據這個思路，我們就可以將上面的程式碼進行改進，使之成為記憶遞迴型的動態規劃程式： 

1. #include <iostream>  
2. #include <algorithm> 
3. usingnamespace std;  
4. #define MAX 101
5. int D[MAX][MAX];      
6. int n;    
7. int maxSum[MAX][MAX];  
8. int MaxSum(int i, int j){        
9.     if( maxSum[i][j] != -1 )           
10.         return maxSum[i][j];        
11.     if(i==n)     
12.         maxSum[i][j] = D[i][j];       
13.     else{      
14.         int x = MaxSum(i+1,j);         
15.         int y = MaxSum(i+1,j+1);         
16.         maxSum[i][j] = max(x,y)+ D[i][j];       
17.     }       
18.     return maxSum[i][j];   
19. }   
20. int main(){      
21.     int i,j;      
22.     cin >> n;      
23.     for(i=1;i<=n;i++)     
24.         for(j=1;j<=i;j++) {         
25.             cin >> D[i][j];         
26.             maxSum[i][j] = -1;     
27.         }      
28.     cout << MaxSum(1,1) << endl;   
29. }   

    當我們提交如上程式碼時，結果就是一次AC

    

    雖然在短時間內就AC了。但是，我們並不能滿足於這樣的程式碼，因為遞迴總是需要使用大量堆疊上的空間，很容易造成棧溢位，我們現在就要考慮如何把遞迴轉換為遞推，讓我們一步一步來完成這個過程。

    我們首先需要計算的是最後一行，因此可以把最後一行直接寫出，如下圖：

    現在開始分析倒數第二行的每一個數，現分析數字2，2可以和最後一行4相加，也可以和最後一行的5相加，但是很顯然和5相加要更大一點，結果為7，我們此時就可以將7儲存起來，然後分析數字7，7可以和最後一行的5相加，也可以和最後一行的2相加，很顯然和5相加更大，結果為12，因此我們將12儲存起來。以此類推。。我們可以得到下面這張圖：

    然後按同樣的道理分析倒數第三行和倒數第四行，最後分析第一行，我們可以依次得到如下結果：

    上面的推導過程相信大家不難理解，理解之後我們就可以寫出如下的遞推型動態規劃程式： 

1. #include <iostream>  
2. #include <algorithm> 
3. usingnamespace std;   
4. #define MAX 101  
5. int D[MAX][MAX];     
6. int n;    
7. int maxSum[MAX][MAX];   
8. int main(){      
9.     int i,j;      
10.     cin >> n;      
11.     for(i=1;i<=n;i++)     
12.         for(j=1;j<=i;j++)          
13.             cin >> D[i][j];     
14.     for( int i = 1;i <= n; ++ i )       
15.         maxSum[n][i] = D[n][i];     
16.     for( int i = n-1; i>= 1;  --i )       
17.         for( int j = 1; j <= i; ++j )           
18.             maxSum[i][j] = max(maxSum[i+1][j],maxSum[i+1][j+1]) + D[i][j];      
19.     cout << maxSum[1][1] << endl;    
20. }   

     我們的程式碼僅僅是這樣就夠了嗎？當然不是，我們仍然可以繼續優化，而這個優化當然是對於空間進行優化，其實完全沒必要用二維maxSum陣列儲存每一個MaxSum(r,j),只要從底層一行行向上遞推，那麼只要一維陣列maxSum[100]即可,即只要儲存一行的MaxSum值就可以。

     對於空間優化後的具體遞推過程如下：