動態規劃演算法

狼爺發表於2020-12-13
動態規劃演算法

一、基本概念

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

二、基本思想與策略

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

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

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

 

三、適用的情況

能採用動態規劃求解的問題的一般要具有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)}

 

六、動態規劃演算法基本框架
複製程式碼
程式碼 
 1 for(j=1; j<=m; j=j+1) // 第一個階段
 2   xn[j] = 初始值;
 3 
 4  for(i=n-1; i>=1; i=i-1)// 其他n-1個階段
 5   for(j=1; j>=f(i); j=j+1)//f(i)與i有關的表示式
 6  xi[j]=j=max（或min）{g(xi-1[j1:j2]), ......, g(xi-1[jk:jk+1])};
 8 
 9 t = g(x1[j1:j2]); // 由子問題的最優解求解整個問題的最優解的方案
10 
11 print(x1[j1]);
12 
13 for(i=2; i<=n-1; i=i+1）
15 { 
17  t = t-xi-1[ji];
18 
19  for(j=1; j>=f(i); j=j+1)
21  if(t=xi[ji])
23  break;
25 }
七、動態規劃經典題目

1.最大連續子序列之和
 解法1—O(N^2)解法
 因為最大連續子序列和只可能從陣列0到n-1中某個位置開始，我們可以遍歷0到n-1個位置，計算由這個位置開始的所有連續子序列和中的最大值。最終求出最大值即可。
 更詳細的講，就是計算從位置0開始的最大連續子序列和，從位置1開始的最大連續子序列和。。。直到從位置n-1開始的最大連續子序列和，最後求出所有這些連續子序列和中的最大值就是答案。
 解法2—O（NlgN）解法
 該問題還可以通過分治法來求解，最大連續子序列和要麼出現在陣列左半部分，要麼出現在陣列右半部分，要麼橫跨左右兩半部分。因此求出這三種情況下的最大值就可以得到最大連續子序列和。
 解法3—O（N）解法
 還有一種更好的解法，只需要O（N）的時間。因為最大 連續子序列和只可能是以位置0～n-1中某個位置結尾。當遍歷到第i個元素時，判斷在它前面的連續子序列和是否大於0，如果大於0，則以位置i結尾的最大連續子序列和為元素i和前門的連續子序列和相加；否則，則以位置i結尾的最大連續子序列和為元素i。
 
package 動態規劃;
public class 最大連續子序列之和 {
	
	public static void main(String args[]) {
		// TODO Auto-generated method stub
		int arr[] = {3,-4,1,5,2};
		System.out.println("解法1—O(N^2)解法 : " + maxsequence1(arr, 5) );
		System.out.println("解法2—O（NlgN）解法 : " + maxsequence2(arr, 1,4) );
		System.out.println("解法3—O（N）解法 : " + maxsequence3(arr, 5) );
			
		
	}
	
	//解法1—O(N^2)解法 :
	public static int maxsequence1(int arr[], int len)  
    {  
        int max = arr[0]; //初始化最大值為第一個元素  
        for (int i=0; i max)  
                    max = sum;  
            }  
        }  
        return max;  
    }  
	
	//解法2—O（NlgN）解法 
   public static int maxsequence2(int a[], int l, int u)  
    {  
        if (l > u) return 0;  
        if (l == u) return a[l];  
        int m = (l + u) / 2;  
      
        /*求橫跨左右的最大連續子序列左半部分*/     
        int lmax=a[m], lsum=0;  
        for (int i=m; i>=l; i--) {  
            lsum += a[i];  
            if (lsum > lmax)  
                lmax = lsum;  
        }  
          
        /*求橫跨左右的最大連續子序列右半部分*/     
        int rmax=a[m+1], rsum = 0;   
        for (int i=m+1; i<=u; i++) {   
            rsum += a[i];  
            if (rsum > rmax)   
                rmax = rsum;   
        }  
        return max3(lmax+rmax, maxsequence2(a, l, m), maxsequence2(a, m+1, u)); //返回三者最大值  
    }  
      
    /*求三個數最大值*/  
   public static  int max3(int i, int j, int k)  
    {  
        if (i>=j && i>=k)  
            return i;  
        return max3(j, k, i);  
    }   
   
   //解法3—O（N）解法
   public static int maxsequence3(int a[], int len)  
   {  
       int maxsum, maxhere;  
       maxsum = maxhere = a[0];   //初始化最大和為a【0】  
       for (int i=1; i maxsum) {  
               maxsum = maxhere;  //更新最大連續子序列和  
           }  
       }  
       return maxsum;  
   }  
}

2.數塔問題
/* 數塔問題： 9 12 15 10 6 8 2 18 9 5 19 7 10 4 16 有形如圖所示的數塔，從頂部出發，在每一結點可以選擇向左走或是向右走， 一直走到底層，要求找出一條路徑，使路徑上的值最大。 這道題如果用列舉法，在數塔層數稍大的情況下（如40），則需要列舉出的路徑條數將是一個非常龐大的數目。 如果用貪心法又往往得不到最優解。 在用動態規劃考慮數塔問題時可以自頂向下的分析，自底向上的計算。 從頂點出發時到底向左走還是向右走應取決於是從左走能取到最大值還是從右走能取到最大值， 只要左右兩道路徑上的最大值求出來了才能作出決策。 同樣的道理下一層的走向又要取決於再下一層上的最大值是否已經求出才能決策。 這樣一層一層推下去，直到倒數第二層時就非常明瞭。 如數字2，只要選擇它下面較大值的結點19前進就可以了。 所以實際求解時，可從底層開始，層層遞進，最後得到最大值。 總結：此題是最為基礎的動態規劃題目，階段、狀態的劃分一目瞭然。       而決策的記錄，充分體現了動態規劃即“記憶化搜尋”的本質。 */  

 
package 動態規劃;

public class 數塔問題 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int i,j;  
	    int data[][] = {  
	            {9,0,0,0,0},  
	            {12,15,0,0,0},  
	            {10,6,8,0,0},  
	            {2,18,9,5,0},  
	            {19,7,10,4,16}  
	        };  
	        for(i = 4; i > 0; i--)  
	            for(j = 0; j < i; j++)  
	                data[i-1][j] += data[i][j] > data[i][j+1] ? data[i][j] : data[i][j+1];  
	          
	       System.out.println(data[0][0]);  
	}

}

3.揹包問題

 
package 動態規劃;

public class 揹包問題 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int v = 10 ;    
	    int n = 5 ;      
	       
	    int value[] = {0, 8 , 10 , 4 , 5 , 5};       
	    int weight[] = {0, 6 , 4 , 2 , 4 , 3};     
	    int i,j;      
	    int[][] dp= new int[n+1][v+1];  
	    for(i = 0; i < n+1; i++)  
	        for(j = 0; j < v+1; j++)  
	            dp[i][j] = 0;  
	  
	  
	    for(i = 1; i <= n; i++){  
	        for(j = 1; j <= v; j++){  
	            if(j >= weight[i])  {
	            	int max = dp[i-1][j]>(dp[i-1][j-weight[i]] + value[i]) ? dp[i-1][j] :(dp[i-1][j-weight[i]] + value[i]);
	            	dp[i][j]=max;
	            }
	            else  
	                dp[i][j] = dp[i-1][j];  
	        }  
	    }  
	  
	    System.out.println(dp[n][v]);  
	}

}


 更多參考：http://blog.csdn.net/zmazon/article/details/8247015











相關文章