一、基本概念

    动态规划是运筹学中用于求解决策过程中的最优化数学方法。当然，我们在这里关注的是作为一种算法设计技术，作为一种使用多阶段决策过程最优的通用方法。

    动态规划过程是：每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。

    假设问题是由交叠的子问题所构成，我们就能够用动态规划技术来解决它。一般来说，这种子问题出自对给定问题求解的递推关系中，这个递推关系包括了同样问题的更小子问题的解。动态规划法建议，与其对交叠子问题一次重新的求解，不如把每一个较小子问题仅仅求解一次并把结果记录在表中（动态规划也是空间换时间的）。这样就能够从表中得到原始问题的解。

    动态规划经常常使用于解决最优化问题，这些问题多表现为多阶段决策。

    关于多阶段决策：在实际中，人们经常遇到这样一类决策问题，即因为过程的特殊性，能够将决策的全过程根据时间或空间划分若干个联系的阶段。而在各阶段中。人们都须要作出方案的选择。我们称之为决策。而且当一个阶段的决策之后，经常影响到下一个阶段的决策，从而影响整个过程的活动。这样，各个阶段所确定的决策就构成一个决策序列，常称之为策略。因为各个阶段可供选择的决策往往不止一个。因而就可能有很多决策以供选择，这些可供选择的策略构成一个集合，我们称之为同意策略集合（简称策略集合）。每一个策略都对应地确定一种活动的效果。我们假定这个效果能够用数量来衡量。

    因为不同的策略经常导致不同的效果，因此，怎样在同意策略集合中选择一个策略，使其在预定的标准下达到最好的效果。经常是人们所关心的问题。我们称这种策略为最优策略，这类问题就称为多阶段决策问题。

多阶段决策问题举例：机器负荷分配问题

    某种机器能够在高低两种不同的负荷下进行生产。在高负荷下生产时。产品的年产量g和投入生产的机器数量x的关系为g=g(x)，这时的年完善率为a，即假设年初完善机器数为x，到年终时完善的机器数为a*x(0<a<1)；在低负荷下生产时，产品的年产量h和投入生产的机器数量y的关系为h=h(y)。对应的完善率为b(0<b<0)。且a<b。

    假定開始生产时完善的机器熟练度为s1。

    要制定一个五年计划，确定每年投入高、低两种负荷生产的完善机器数量，使5年内产品的总产量达到最大。

    这是一个多阶段决策问题。

    显然能够将全过程划分为5个阶段（一年一个阶段），每一个阶段開始时要确定投入高、低两种负荷下生产的完善机器数，并且上一个阶段的决策必定影响到下一个阶段的生产状态。决策的目标是使产品的总产量达到最大。这个问题常常使用数学方法建模，结合线性规划等知识来进行解决。

二、基本思想与策略

          基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了实用的信息。

    在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其它局部解。依次解决各子问题，最后一个子问题就是初始问题的解。

    因为动态规划解决的问题多数有重叠子问题这个特点。为降低反复计算。对每个子问题仅仅解一次，将其不同阶段的不同状态保存在一个二维数组中。

    与分治法最大的区别是：适合于用动态规划法求解的问题，经分解后得到的子问题往往不是互相独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）。

三、适用的情况

能采用动态规划求解的问题的一般要具有3个性质：

（1）最优化原理：假设问题的最优解所包括的子问题的解也是最优的，就称该问题具有最优子结构，即满足最优化原理。

（2）无后效性：即某阶段状态一旦确定。就不受这个状态以后决策的影响。也就是说，某状态以后的过程不会影响曾经的状态。仅仅与当前状态有关；

（3）有重叠子问题：即子问题之间是不独立的，一个子问题在下一阶段决策中可能被多次使用到（该性质并非动态规划适用的必要条件，可是假设没有这条性质。动态规划算法同其它算法相比就不具备优势）。

四、求解的基本步骤

     动态规划所处理的问题是一个多阶段决策问题，一般由初始状态开始，通过对中间阶段决策的选择，达到结束状态。这些决策形成了一个决策序列，同时确定了完成整个过程的一条活动路线(通常是求最优的活动路线)。如图所示。动态规划的设计都有着一定的模式，一般要经历以下几个步骤。

    初始状态→│决策１│→│决策２│→…→│决策ｎ│→结束状态

                      图1 动态规划决策过程示意图

    (1)划分阶段：按照问题的时间或空间特征，把问题分为若干个阶段。在划分阶段时，注意划分后的阶段一定要是有序的或者是可排序的，否则问题就无法求解。

    (2)确定状态和状态变量：将问题发展到各个阶段时所处于的各种客观情况用不同的状态表示出来。当然，状态的选择要满足无后效性。

    (3)确定决策并写出状态转移方程：因为决策和状态转移有着天然的联系，状态转移就是根据上一阶段的状态和决策来导出本阶段的状态。所以如果确定了决策，状态转移方程也就可写出。但事实上常常是反过来做，根据相邻两个阶段的状态之间的关系来确定决策方法和状态转移方程。

    (4)寻找边界条件：给出的状态转移方程是一个递推式，需要一个递推的终止条件或边界条件。

    一般，只要解决问题的阶段、状态和状态转移决策确定了，就可以写出状态转移方程（包括边界条件）。

实际应用中可以按以下几个简化的步骤进行设计：

    （1）分析最优解的性质，并刻画其结构特征。

    （2）递归的定义最优解。

    （3）以自底向上或自顶向下的记忆化方式（备忘录法）计算出最优值。

    （4）根据计算优值时得到的信息，构造问题的最优解。

五、常见动态规划问题

 1、找零钱问题

     有数组penny，penny中所有的值都为正数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个整数aim(小于等于1000)代表要找的钱数，求换钱有多少种方法。
给定数组penny及它的大小(小于等于50)，同时给定一个整数aim，请返回有多少种方法可以凑成aim。
测试样例：
[1,2,4],3,3
返回：2

解析：设dp[n][m]为使用前n中货币凑成的m的种数，那么就会有两种情况：

             使用第n种货币：dp[n-1][m]+dp[n-1][m-peney[n]]

              不用第n种货币：dp[n-1][m]，为什么不使用第n种货币呢，因为penney[n]>m。

        这样就可以求出当m>=penney[n]时 dp[n][m] = dp[n-1][m]+dp[n][m-peney[n]]，否则，dp[n][m] = dp[n-1][m]

代码如下：

[java] 
view plain
 copy

1. import java.util.*;  
2. public class Exchange {  
3.     public int countWays(int[] penny, int n, int aim) {  
4.         // write code here  
5.         if(n==0||penny==null||aim<0){  
6.          return 0;     
7.         }  
8.         int[][] pd = new int[n][aim+1];  
9.         for(int i=0;i<n;i++){  
10.          pd[i][0] = 1;     
11.         }  
12.         for(int i=1;penny[0]*i<=aim;i++){  
13.          pd[0][penny[0]*i] = 1;     
14.         }  
15.         for(int i=1;i<n;i++){  
16.             for(int j=0;j<=aim;j++){  
17.                 if(j>=penny[i]){  
18.                     pd[i][j] = pd[i-1][j]+pd[i][j-penny[i]];  
19.                 }else{  
20.                     pd[i][j] = pd[i-1][j];  
21.                 }  
22.             }  
23.         }  
24.         return pd[n-1][aim];  
25.     }   

2、走方格问题

      有一个矩阵map，它每个格子有一个权值。从左上角的格子开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，返回所有的路径中最小的路径和。
给定一个矩阵map及它的行数n和列数m，请返回最小路径和。保证行列数均小于等于100.
测试样例：
[[1,2,3],[1,1,1]],2,3
返回：4

解析：设dp[n][m]为走到n*m位置的路径长度，那么显而易见dp[n][m] = min(dp[n-1][m],dp[n][m-1]);

 代码如下：

[java] 
view plain
 copy

1. import java.util.*;    
2. public class MinimumPath {  
3.     public int getMin(int[][] map, int n, int m) {  
4.         // write code here  
5.        int[][] dp = new int[n][m];  
6.         for(int i=0;i<n;i++){  
7.             for(int j=0;j<=i;j++){  
8.              dp[i][0]+=map[j][0];      
9.             }  
10.         }  
11.         for(int i=0;i<m;i++){  
12.             for(int j=0;j<=i;j++){  
13.              dp[0][i]+=map[0][j];      
14.             }  
15.         }  
16.         for(int i=1;i<n;i++){  
17.             for(int j=1;j<m;j++){  
18.              dp[i][j] = min(dp[i][j-1]+map[i][j],dp[i-1][j]+map[i][j]);     
19.             }  
20.         }  
21.         return dp[n-1][m-1];  
22.     }  
23.     public int min(int a,int b){  
24.         if(a>b){  
25.          return b;     
26.         }else{  
27.          return a;     
28.         }  
29.     }  

3、走台阶问题

    有n级台阶，一个人每次上一级或者两级，问有多少种走完n级台阶的方法。为了防止溢出，请将结果Mod 1000000007
给定一个正整数int n，请返回一个数，代表上楼的方式数。保证n小于等于100000。
测试样例：
1
返回：1

解析：这是一个非常经典的为题，设f(n)为上n级台阶的方法，要上到n级台阶的最后一步有两种方式：从n-1级台阶走一步；从n-1级台阶走两步，于是就有了这个公式f(n) = f(n-1)+f(n-2);

代码如下：

[java] 
view plain
 copy

1. import java.util.*;  
2. public class GoUpstairs {  
3.     public int countWays(int n) {  
4.         // write code here  
5.         if(n<=2)  
6.             return n;  
7.         int f = 1%1000000007;  
8.         int s = 2%1000000007;  
9.         int t = 0;  
10.         for(int i=3;i<=n;i++){  
11.          t = (f+s)%1000000007;  
12.          f = s;  
13.          s = t;  
14.         }  
15.        return t;   
16.     }  
17. }

4、最长公共序列数

     给定两个字符串A和B，返回两个字符串的最长公共子序列的长度。例如，A=”1A2C3D4B56”，B=”B1D23CA45B6A”，”123456″或者”12C4B6″都是最长公共子序列。
给定两个字符串A和B，同时给定两个串的长度n和m，请返回最长公共子序列的长度。保证两串长度均小于等于300。
测试样例：
“1A2C3D4B56″,10,”B1D23CA45B6A”,12
返回：6

解析：设dp[n][m] ，为A的前n个字符与B的前m个字符的公共序列长度，则当A[n]==B[m]的时候，dp[i][j] = max(dp[i-1][j-1]+1,dp[i-1][j],dp[i][j-1])，否则，dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);

代码如下：

[java] 
view plain
 copy

1. import java.util.*;  
2. public class LCS {  
3.     public int findLCS(String A, int n, String B, int m) {  
4.         // write code here  
5.         int[][] dp = new int[n][m];  
6.         char[] a = A.toCharArray();  
7.         char[] b = B.toCharArray();  
8.        for(int i=0;i<n;i++){  
9.            if(a[i]==b[0]){  
10.                dp[i][0] = 1;  
11.                for(int j=i+1;j<n;j++){  
12.                    dp[j][0] = 1;  
13.                }  
14.                break;  
15.            }       
16.        }  
17.          for(int i=0;i<m;i++){  
18.            if(a[0]==b[i]){  
19.                dp[0][i] = 1;  
20.                for(int j=i+1;j<m;j++){  
21.                    dp[0][j] = 1;  
22.                }  
23.                break;  
24.            }       
25.        }  
26.        for(int i=1;i<n;i++){  
27.            for(int j=1;j<m;j++){  
28.                if(a[i]==b[j]){  
29.                   dp[i][j] = max(dp[i-1][j-1]+1,dp[i-1][j],dp[i][j-1]);  
30.                }else{  
31.                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);  
32.                }               
33.            }  
34.        }       
35.         return dp[n-1][m-1];  
36.     }  
37.     public int max(int a,int b,int c){  
38.         int max = a;  
39.         if(b>max)  
40.             max=b;  
41.         if(c>max)  
42.             max = c;  
43.         return max;  
44.     }  
45. }