前言：動態規划的概念
動態規划（dynamic programming）是通過組合子問題的解而解決整個問題的。分治算法是指將問題划分為一些獨立的子問題，遞歸的求解各個問題，然后合並子問題的解而得到原問題的解。例如歸並排序，快速排序都是采用分治算法思想。本書在第二章介紹歸並排序時，詳細介紹了分治算法的操作步驟，詳細的內容請參考：http://www.cnblogs.com/Anker/archive/2013/01/22/2871042.html。而動態規划與此不同，適用於子問題不是獨立的情況，也就是說各個子問題包含有公共的子問題。如在這種情況下，用分治算法則會重復做不必要的工作。采用動態規划算法對每個子問題只求解一次，將其結果存放到一張表中，以供后面的子問題參考，從而避免每次遇到各個子問題時重新計算答案。
動態規划與分治法之間的區別：
（1）分治法是指將問題分成一些獨立的子問題，遞歸的求解各子問題
（2）動態規划適用於這些子問題不是獨立的情況，也就是各子問題包含公共子問題
動態規划通常用於最優化問題（此類問題一般有很多可行解，我們希望從這些解中找出一個具有最優（最大或最小）值的解）。動態規划算法的設計分為以下四個步驟：
（1）描述最優解的結構
（2）遞歸定義最優解的值
（3）按自低向上的方式計算最優解的值
（4）由計算出的結果構造一個最優解
動態規划最重要的就是要找出最優解的子結構。書中接下來列舉4個問題，講解如何利用動態規划方法來解決。動態規划的內容比較多，我計划每個問題都認真分析，寫成日志。今天先來看第一個問題：裝配線調度問題
2、問題描述
一個汽車公司在有2條裝配線的工廠內生產汽車，每條裝配線有n個裝配站，不同裝配線上對應的裝配站執行的功能相同，但是每個站執行的時間是不同的。在裝配汽車時，為了提高速度，可以在這兩天裝配線上的裝配站中做出選擇，即可以將部分完成的汽車在任何裝配站上從一條裝配線移到另一條裝配線上。裝配過程如下圖所示：
裝配過程的時間包括：進入裝配線時間e、每裝配線上各個裝配站執行時間a、從一條裝配線移到另外一條裝配線的時間t、離開最后一個裝配站時間x。舉個例子來說明，現在有2條裝配線，每條裝配線上有6個裝配站，各個時間如下圖所示：
從圖中可以看出按照紅色箭頭方向進行裝配汽車最快，時間為38。分別現在裝配線1上的裝配站1、3和6，裝配線2上裝配站2、4和5。
3、動態規划解決步驟
（1）描述通過工廠最快線路的結構
對於裝配線調度問題，一個問題的（找出通過裝配站Si,j的 最快線路）最優解包含了子問題（找出通過S1,j-1或S2,j-1的最快線路）的一個最優解，這就是最優子結構。觀察一條通過裝配站S1,j的最快線路，會發現它必定是經過裝配線1或2上裝配站j-1。因此通過裝配站的最快線路只能以下二者之一：
a)通過裝配線S1,j-1的最快線路，然后直接通過裝配站Si,j；
b)通過裝配站S2,j-1的最快線路，從裝配線2移動到裝配線1，然后通過裝配線S1,j。
為了解決這個問題，即尋找通過一條裝配線上的裝配站j的最快線路，需要解決其子問題，即尋找通過兩條裝配線上的裝配站j-1的最快線路。
（2）一個遞歸的解
最終目標是確定底盤通過工廠的所有路線的最快時間，設為f*，令fi[j]表示一個底盤從起點到裝配站Si,j的最快時間，則f* = min(f1[n]+x1,f2[n]+x2)。逐步向下推導，直到j=1。
當j=1時: f1[1] = e1+a1,1,f2[1] = e2+a2,1。
當j>1時：f1[j] = min(f1[j-1]+a1,j，f2[j-1]+t2,j-1+a1,j)，f2[j] = min(f2[j-1]+a2,j，f1[j-1]+t1,j-1+a2,j)。
（3）計算最快時間
有了遞歸的解，就可以按照上述的思路編寫程序實現，為了避免用遞歸實現，需要開辟輔助空間來進行，以空間來換取時間，用C語言實現如下所示：
1 void fastest_way(int a[][N],int t[][N-1],int e[],int x[],int f[][N],int l[][N],int n) 2 { 3 int i,j; 4 f[0][0] = e[0] + a[0][0]; 5 f[1][0] = e[1] + a[1][0]; 6 l[0][0] = 1; 7 l[1][0] = 2; 8 for(j=1;j<n;j++) 9 { 10 if(f[0][j-1] < f[1][j-1] + t[1][j-1]) 11 { 12 f[0][j] = f[0][j-1] + a[0][j]; 13 l[0][j] = 1; 14 } 15 else 16 { 17 f[0][j] = f[1][j-1] + t[1][j-1] + a[0][j]; 18 l[0][j] = 2; 19 } 20 if(f[1][j-1] < f[0][j-1] + t[0][j-1]) 21 { 22 f[1][j] = f[1][j-1] + a[1][j]; 23 l[1][j] = 2; 24 } 25 else 26 { 27 f[1][j] = f[0][j-1] + t[0][j-1] + a[1][j]; 28 l[1][j] = 1; 29 } 30 } 31 if(f[0][n-1] + x[0] < f[1][n-1] + x[1]) 32 { 33 last_f = f[0][n-1] + x[0]; 34 last_l = 1; 35 } 36 else 37 { 38 last_f = f[1][n-1] + x[1]; 39 last_l = 2; 40 } 41 }
（4）構造通過工廠的最快線路
有第三步驟已經計算出來並記錄了每個裝配站所在的裝配線編號，故可以按照以站號遞減順序直接輸出，程序如下所示：
1 void print_station(int l[][N],int last_l,int n) 2 { 3 int i = last_l; 4 int j; 5 printf("line %d,station %d\n",i,n); 6 for(j=n-1;j>0;--j) 7 { 8 i = l[i-1][j]; 9 printf("line %d,station %d\n",i,j); 10 } 11 }
若是按照站號遞增順序輸出，則需通過遞歸進行實現，程序如下所示：
1 void print_station_recursive(int l[][N],int last_l,int n) 2 { 3 int i = last_l; 4 if(n == 1) 5 printf("line %d,station %d\n",i,n); 6 else 7 { 8 print_station_recursive(l,l[i-1][n-1],n-1); 9 printf("line %d,station %d\n",i,n); 10 } 11 12 }
4、編程實現
根據上面的分析，采用C語言實現如下：
1 #include <stdio.h> 2 #include <stdlib.h> 3 4 #define N 6 5 6 void fastest_way(int a[][N],int t[][N-1],int e[],int x[],int f[][N],int l[][N],int n); 7 void print_station(int l[][N],int last_l,int n); 8 void print_station_recursive(); 9 //全局變量，last_t表示最短時間,last_l表示最后一個裝配站所在的裝配線編號 10 int last_f,last_l; 11 12 int main() 13 { 14 int a[2][6] = {{7,9,3,4,8,4},{8,5,6,4,5,7}}; 15 int t[2][5] = {{2,3,1,3,4},{2,1,2,2,1}}; 16 int f[2][6] = {0}; 17 int l[2][6] = {0}; 18 int e[2] = {2,4}; 19 int x[2] = {3,2}; 20 int i,j; 21 fastest_way(a,t,e,x,f,l,6); 22 //打印輸出各個裝配線上各個裝配站執行的最短時間 23 for(i=0;i<2;++i) 24 { 25 printf("f%d is: ",i+1); 26 for(j=0;j<6;++j) 27 printf("%d ",f[i][j]); 28 printf("\n"); 29 } 30 printf("last_f is: %d\nlast_l is: %d\n",last_f,last_l); 31 for(i=0;i<2;++i) 32 { 33 printf("l%d is: ",i+1); 34 for(j=0;j<6;++j) 35 printf("%d ",l[i][j]); 36 printf("\n"); 37 } 38 print_station(l,last_l,6); 39 printf("output sequence by recursive.\n"); 40 print_station_recursive(l,last_l,6); 41 return 0; 42 } 43 44 void fastest_way(int a[][N],int t[][N-1],int e[],int x[],int f[][N],int l[][N],int n) 45 { 46 int i,j; 47 f[0][0] = e[0] + a[0][0]; 48 f[1][0] = e[1] + a[1][0]; 49 l[0][0] = 1; 50 l[1][0] = 2; 51 for(j=1;j<n;j++) 52 { 53 if(f[0][j-1] < f[1][j-1] + t[1][j-1]) 54 { 55 f[0][j] = f[0][j-1] + a[0][j]; 56 l[0][j] = 1; 57 } 58 else 59 { 60 f[0][j] = f[1][j-1] + t[1][j-1] + a[0][j]; 61 l[0][j] = 2; 62 } 63 if(f[1][j-1] < f[0][j-1] + t[0][j-1]) 64 { 65 f[1][j] = f[1][j-1] + a[1][j]; 66 l[1][j] = 2; 67 } 68 else 69 { 70 f[1][j] = f[0][j-1] + t[0][j-1] + a[1][j]; 71 l[1][j] = 1; 72 } 73 } 74 if(f[0][n-1] + x[0] < f[1][n-1] + x[1]) 75 { 76 last_f = f[0][n-1] + x[0]; 77 last_l = 1; 78 } 79 else 80 { 81 last_f = f[1][n-1] + x[1]; 82 last_l = 2; 83 } 84 } 85 86 void print_station(int l[][N],int last_l,int n) 87 { 88 int i = last_l; 89 int j; 90 printf("line %d,station %d\n",i,n); 91 for(j=n-1;j>0;--j) 92 { 93 i = l[i-1][j]; 94 printf("line %d,station %d\n",i,j); 95 } 96 } 97 void print_station_recursive(int l[][N],int last_l,int n) 98 { 99 int i = last_l; 100 if(n == 1) 101 printf("line %d,station %d\n",i,n); 102 else 103 { 104 print_station_recursive(l,l[i-1][n-1],n-1); 105 printf("line %d,station %d\n",i,n); 106 } 107 108 }
程序執行結果如下所示：
5、總結
動態規划是個非常有效的設計方法，要善於用動態規划去分析問題，重點是如何發現子問題的結構。最優子結構在問題域中以兩種方式變化（在找出這兩個問題的解之后，構造出原問題的最優子結構往往就不是難事了）：
a) 有多少個子問題被用在原問題的一個最優解中
b) 在決定一個最優解中使用哪些子問題有多少個選擇