动态规划问题学习路线：斐波那契数列，最大递增子序列，松鼠捡苹果，最大公共子序列，字符串编辑距离

来源：互联网发布：ftp 自定义端口编辑：程序博客网时间：2024/05/17 02:12

基本思想：若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，从而减少计算量：一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。这种做法在重复子问题的数目关于输入的规模呈指数增长时特别有用。

核心：记忆化搜索与递归

下面来看几个具体的问题，由浅入深，逐步学习动态规划的思想

1.斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368......

这个数列从第3项开始，每一项都等于前两项之和。

import java.util.Scanner;public class Fibonacci {public static int Fib(int n){if(n==0 || n==1)      {          return 1;      }      else      {          return Fib(n-1) + Fib(n-2);      }  }public static void main(String[] args) {// TODO Auto-generated method stubScanner scanner=new Scanner(System.in);int number=scanner.nextInt();System.out.println(Fib(number));}}

以上代码在n=5时，fib(5)的计算过程如下:

fib(5)
fib(4) + fib(3)
(fib(3) + fib(2)) + (fib(2) + fib(1))
((fib(2) + fib(1)) + (fib(1) + fib(0))) + ((fib(1) + fib(0)) + fib(1))
(((fib(1) + fib(0)) + fib(1)) + (fib(1) + fib(0))) + ((fib(1) + fib(0)) + fib(1))

由上面可以看出，这种算法对于相似的子问题进行了重复的计算，因此不是一种高效的算法。实际上，该算法的运算时间是指数级增长的。改进的方法是，我们可以通过保存已经算出的子问题的解来避免重复计算：

import java.util.Scanner;public class Fibonacci {final static int MAX=1000;public static void main(String[] args) {// TODO Auto-generated method stubScanner scanner=new Scanner(System.in);int number=scanner.nextInt();int[] fib=new int[MAX];fib[0]=0;fib[1]=1;for (int i = 2; i <= number; i++) {fib[i]=fib[i-1]+fib[i-2];}System.out.println(fib[number]);}}

将前n个已经算出的前n个数保存在数组map中，这样在后面的计算中可以直接易用前面的结果，从而避免了重复计算。算法的运算时间变为O(n)。

2.找硬币

如果我们有面值为1元、3元和5元的硬币若干枚，如何用最少的硬币凑够11元？ (表面上这道题可以用贪心算法，但贪心算法无法保证可以求出解，比如1元换成2元的时候)

首先我们思考一个问题，如何用最少的硬币凑够i元(i<11)？为什么要这么问呢？两个原因：1.当我们遇到一个大问题时，总是习惯把问题的规模变小，这样便于分析讨论。 2.这个规模变小后的问题和原来的问题是同质的，除了规模变小，其它的都是一样的，本质上它还是同一个问题(规模变小后的问题其实是原问题的子问题)。

好了，让我们从最小的i开始吧。当i=0，即我们需要多少个硬币来凑够0元。由于1，3，5都大于0，即没有比0小的币值，因此凑够0元我们最少需要0个硬币。 (这个分析很傻是不是？别着急，这个思路有利于我们理清动态规划究竟在做些什么。) 这时候我们发现用一个标记来表示这句“凑够0元我们最少需要0个硬币。”会比较方便，如果一直用纯文字来表述，不出一会儿你就会觉得很绕了。那么，我们用d(i)=j来表示凑够i元最少需要j个硬币。于是我们已经得到了d(0)=0，表示凑够0元最小需要0个硬币。当i=1时，只有面值为1元的硬币可用，因此我们拿起一个面值为1的硬币，接下来只需要凑够0元即可，而这个是已经知道答案的，即d(0)=0。所以，d(1)=d(1-1)+1=d(0)+1=0+1=1。当i=2时，仍然只有面值为1的硬币可用，于是我拿起一个面值为1的硬币，接下来我只需要再凑够2-1=1元即可(记得要用最小的硬币数量)，而这个答案也已经知道了。所以d(2)=d(2-1)+1=d(1)+1=1+1=2。一直到这里，你都可能会觉得，好无聊，感觉像做小学生的题目似的。因为我们一直都只能操作面值为1的硬币！耐心点，让我们看看i=3时的情况。当i=3时，我们能用的硬币就有两种了：1元的和3元的( 5元的仍然没用，因为你需要凑的数目是3元！5元太多了亲)。既然能用的硬币有两种，我就有两种方案。如果我拿了一个1元的硬币，我的目标就变为了：凑够3-1=2元需要的最少硬币数量。即d(3)=d(3-1)+1=d(2)+1=2+1=3。这个方案说的是，我拿3个1元的硬币；第二种方案是我拿起一个3元的硬币，我的目标就变成：凑够3-3=0元需要的最少硬币数量。即d(3)=d(3-3)+1=d(0)+1=0+1=1. 这个方案说的是，我拿1个3元的硬币。好了，这两种方案哪种更优呢？记得我们可是要用最少的硬币数量来凑够3元的。所以，选择d(3)=1，怎么来的呢？具体是这样得到的：d(3)=min{d(3-1)+1, d(3-3)+1}。

OK，码了这么多字讲具体的东西，让我们来点抽象的。从以上的文字中，我们要抽出动态规划里非常重要的两个概念：状态和状态转移方程。

上文中d(i)表示凑够i元需要的最少硬币数量，我们将它定义为该问题的"状态"，这个状态是怎么找出来的呢？

你找到子问题，状态也就浮出水面了。最终我们要求解的问题，可以用这个状态来表示：d(11)，即凑够11元最少需要多少个硬币。那状态转移方程是什么呢？既然我们用d(i)表示状态，那么状态转移方程自然包含d(i)，上文中包含状态d(i)的方程是：d(3)=min{d(3-1)+1, d(3-3)+1}。没错，它就是状态转移方程，描述状态之间是如何转移的。当然，我们要对它抽象一下，

d(i)=min{ d(i-v_j)+1 }，其中i-v_j >=0，v_j表示第j个硬币的面值;

有了状态和状态转移方程，这个问题基本上也就解决了。当然了，Talk is cheap,show me the code!

public class DP {/** * 数钱币问题 * @param args */public static void main(String[] args) {// TODO Auto-generated method stubint[] min=new int[12];min[0]=0;for(int i=1;i<12;i++){if(i<3) min[i]=min[i-1]+1;else if(i<5) min[i]=Math.min(min[i-1]+1, min[i-3]+1);else{min[i]=Math.min(min[i-1]+1, min[i-3]+1);if(min[i-5]+1<min[i]) min[i]=min[i-5]+1;}}for(int i=0;i<12;i++)System.out.println(min[i]);}}

下图是当i从0到11时的解：

从上图可以得出，要凑够11元至少需要3枚硬币。

此外，通过追踪我们是如何从前一个状态值得到当前状态值的，可以找到每一次我们用的是什么面值的硬币。比如，从上面的图我们可以看出，最终结果d(11)=d(10)+1(面值为1)，而d(10)=d(5)+1(面值为5)，最后d(5)=d(0)+1 (面值为5)。所以我们凑够11元最少需要的3枚硬币是：1元、5元、5元。

初级动态规划

上面讨论了一个非常简单的例子。现在让我们来看看对于更复杂的问题，如何找到状态之间的转移方式(即找到状态转移方程)。为此我们要引入一个新词叫递推关系来将状态联系起来(说的还是状态转移方程)

OK，再看一个例子，看看它是如何工作的。

3.最长递增子序列

一个序列有N个数：A[1],A[2],…,A[N]，求出最长非降子序列的长度。 (讲DP基本都会讲到的一个问题LIS：longest increasing subsequence)

正如上面我们讲的，面对这样一个问题，我们首先要定义一个“状态”来代表它的子问题，并且找到它的解。注意，大部分情况下，某个状态只与它前面出现的状态有关，而独立于后面的状态。

让我们沿用“入门”一节里那道简单题的思路来一步步找到“状态”和“状态转移方程”。假如我们考虑求A[1],A[2],…,A[i]的最长非降子序列的长度，其中i<N，那么上面的问题变成了原问题的一个子问题(问题规模变小了，你可以让i=1,2,3等来分析) 然后我们定义d(i)，表示前i个数中以A[i]结尾的最长非降子序列的长度。OK，对照“入门”中的简单题，你应该可以估计到这个d(i)就是我们要找的状态。如果我们把d(1)到d(N)都计算出来，那么最终我们要找的答案就是这里面最大的那个。状态找到了，下一步找出状态转移方程。

为了方便理解我们是如何找到状态转移方程的，我先把下面的例子提到前面来讲。如果我们要求的这N个数的序列是：

5，3，4，8，6，7

根据上面找到的状态，我们可以得到：（下文的最长非降子序列都用LIS表示）

前1个数的LIS长度d(1)=1(序列：5)
前2个数的LIS长度d(2)=1(序列：3；3前面没有比3小的)
前3个数的LIS长度d(3)=2(序列：3，4；4前面有个比它小的3，所以d(3)=d(2)+1)
前4个数的LIS长度d(4)=3(序列：3，4，8；8前面比它小的有3个数，所以 d(4)=max{d(1),d(2),d(3)}+1=3)

OK，分析到这，我觉得状态转移方程已经很明显了，如果我们已经求出了d(1)到d(i-1)，那么d(i)可以用下面的状态转移方程得到：

d(i) = max{1, d(j)+1},其中j<i,A[j]<=A[i]

用大白话解释就是，想要求d(i)，就把i前面的各个子序列中，最后一个数不大于A[i]的序列长度加1，然后取出最大的长度即为d(i)。当然了，有可能i前面的各个子序列中最后一个数都大于A[i]，那么d(i)=1，即它自身成为一个长度为1的子序列。

分析完了，上图：(第二列表示前i个数中LIS的长度，第三列表示，LIS中到达当前这个数的上一个数的下标，根据这个可以求出LIS序列)

Talk is cheap, show me the code:

public class DP2 {/** * 最长自增序列问题 */final static int length=6;public static void main(String[] args) {// TODO Auto-generated method stubint[] number={5,3,4,8,6,7};/**for(int i=0;i<length;i++)number[i]=(int )(Math.random()*100);*/int[] dp=new int[length];int max=1;for(int i=0;i<length;i++)dp[i]=1;for(int i=0;i<length;i++)for(int j=0;j<i;j++){if(number[j]<number[i] && dp[j]+1>dp[i])dp[i]=dp[j]+1;if(dp[i]>max) max=dp[i];}for(int i=0;i<length;i++)System.out.print(number[i]+" ");System.out.println();System.out.println("max="+max);for(int i=0;i<length;i++)System.out.println(dp[i]);}}

在这里用到两层for循环，我来分别解释下

在外层for循环表示游标数到了子序列的第i个位置。

if(number[j]<number[i] && dp[j]+1>dp[i])
dp[i]=dp[j]+1;
是状态转移的条件，有人可能要问道，“number[j]<number[i]”只是判定子序列中前后两个数的大小，你怎么能确定，子序列一次递增呢？，在这里dp[i]=dp[j]+1;内层循环中自增序列后边的dp[front]<dp[back],dp[i]=dp[back]+1会覆盖dp[i]=dp[front]+1.这就默认了子序列是递增的。

该算法的时间复杂度是O(n² )，并不是最优的解法。

中级动态规划

接下来，让我们来看看如何解决二维的DP问题。

4.松鼠吃苹果

平面上有N＊M个格子，每个格子中放着一定数量的苹果。松鼠从左上角的格子开始，每一步只能向下走或是向右走，每次走到一个格子上就把格子里的苹果收集起来，这样下去，你帮松鼠算一下，它最多能收集到多少个苹果。

解这个问题与解其它的DP问题几乎没有什么两样。直观上也很容易想：第一步找到问题的“状态”，第二步找到“状态转移方程”，然后基本上问题就解决了。

首先，我们要找到这个问题中的“状态”是什么？我们必须注意到的一点是，到达一个格子的方式最多只有两种：从左边来的(除了第一列)和从上边来的(除了第一行)。因此为了求出到达当前格子后最多能收集到多少个苹果，我们就要先去考察那些能到达当前这个格子的格子，到达它们最多能收集到多少个苹果。 (是不是有点绕，但这句话的本质其实是DP的关键：欲求问题的解，先要去求子问题的解)

经过上面的分析，很容易可以得出问题的状态和状态转移方程。状态S[i][j]表示我们走到(i, j)这个格子时，最多能收集到多少个苹果。那么，状态转移方程如下：

S[i][j]=A[i][j] + max(S[i-1][j], if i>0 ; S[i][j-1], if j>0)

其中i代表行，j代表列，下标均从0开始；A[i][j]代表格子(i, j)处的苹果数量。

S[i][j]有两种计算方式：1.对于每一行，从左向右计算，然后从上到下逐行处理；2. 对于每一列，从上到下计算，然后从左向右逐列处理。这样做的目的是为了在计算S[i][j]时，S[i-1][j]和S[i][j-1]都已经计算出来了。

伪代码如下：

public class DP3 {final static int row=4;final static int colums=5;public static void main(String[] args) {// TODO Auto-generated method stubint[][] mat=new int[row][colums];for(int i=0;i<row;i++)for(int j=0;j<colums;j++)mat[i][j]=(int )(Math.random()*2.5);for(int i=0;i<row;i++){for(int j=0;j<colums;j++)System.out.print(mat[i][j]+ " ");System.out.println();}int[][] max=new int[row][colums];max[0][0]=mat[0][0];for (int i = 0; i < mat.length; i++) {for (int j = 0; j < mat[0].length; j++) {if(i==0 && j>0) max[i][j]=max[i][j-1]+mat[i][j];if (j==0 && i>0) {max[i][j]=max[i-1][j]+mat[i-1][j];}if(i>0 && j>0)max[i][j]=Math.max(max[i-1][j]+mat[i][j], max[i][j-1]+mat[i][j]);}}System.out.println("output:");for (int i = 0; i < max.length; i++) {for (int j = 0; j < max[0].length; j++) {System.out.print(max[i][j]+" ");}System.out.println();}}}

运行结果：
0 0 0 2 0
1 2 1 1 0
2 1 0 1 1
0 0 1 1 1
output:
0 0 0 2 2
0 2 3 4 4
1 3 3 5 6
3 3 4 6 7

中高级动态规划

5.求两字符序列的最长公共字符子序列

问题描述：字符序列的子序列是指从给定字符序列中随意地（不一定连续）去掉若干个字符（可能一个也不去掉）后所形成的字符序列。令给定的字符序列X=“x0，x1，…，xm-1”，序列Y=“y0，y1，…，yk-1”是X的子序列，存在X的一个严格递增下标序列<i0，i1，…，ik-1>，使得对所有的j=0，1，…，k-1，有xij=yj。例如，X=“ABCBDAB”，Y=“BCDB”是X的一个子序列。

蛮力法：蛮力法是解决最长公共子序列问题最容易想到的方法，即对S的每一个子序列，检查是否为T的子序列，从而确定它是否为S和T的公共子序列，并且选出最长的公共子序列。

S和T的所有子序列都检查过后即可求出S和T的最长公共子序列。S的一个子序列相应于下标序列1,2，...，n的一个子序列。因此，S共有2^n个子序列。当然，T也有2^m个子序列。

因此，蛮力法的时间复杂度为O(2^n * 2^m)，这可是指数级别的啊。

想一想上一题的“松鼠吃苹果”，有什么启发吗？如何减少不必要的中间结果的计算，充分利用计算机的存储能力和迭代计算能力？

求解：

引进一个二维数组c[][]，用c[i][j]记录X[i]与Y[j] 的LCS 的长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，以决定搜索的方向。
我们是自底向上进行递推计算，那么在计算c[i,j]之前，c[i-1][j-1]，c[i-1][j]与c[i][j-1]均已计算出来。此时我们根据X[i] = Y[j]还是X[i] != Y[j]，就可以计算出c[i][j]。

问题的递归式写成：

recursive formula

回溯输出最长公共子序列过程：

输出一个最长公共子序列并不难（网上很多相关代码），难点在于输出所有的最长公共子序列，因为 LCS 通常不唯一。总之，我们需要在动态规划表上进行回溯 —— 从table[m][n]，即右下角的格子，开始进行判断：

如果格子table[i][j]对应的X[i-1] == Y[j-1]，则把这个字符放入 LCS 中，并跳入table[i-1][j-1]中继续进行判断；
如果格子table[i][j]对应的 X[i-1] ≠ Y[j-1]，则比较table[i-1][j]和table[i][j-1]的值，跳入值较大的格子继续进行判断；
直到 i 或 j 小于等于零为止，倒序输出 LCS 。

如果出现table[i-1][j]等于table[i][j-1]的情况，说明最长公共子序列有多个，故两边都要进行回溯（这里用到递归）。

从上图的红色路径显示，X 和 Y 的最长公共子序列有 3 个，分别为 “BDAB”、“BCAB”、“BCBA”。

talk is cheap，show me the code!

import java.util.Scanner;public class LCS {private static void SubSequence(String buf,String flag[][],int i,int j) {// TODO Auto-generated method stub/** * 递归方法，打印输出路径 */if(i==0 || j==0)return;if(flag[i][j]=="left_up"){System.out.print(buf.charAt(j-1)+" ");SubSequence(buf, flag, i-1, j-1);}else {if(flag[i][j]=="up")SubSequence(buf, flag, i-1, j);if(flag[i][j]=="left")SubSequence(buf, flag, i, j-1);return;}}public static void main(String[] args) {// TODO Auto-generated method stubScanner scanner= new Scanner(System.in);String buffer1=scanner.nextLine();String buffer2=scanner.nextLine();int m=buffer1.length();int n=buffer2.length();int[][] mat=new int[m+1][n+1];String[][] flag=new String[m+1][n+1];for (int i = 1; i < mat.length; i++) {for (int j = 1; j < mat[0].length; j++) {if(buffer1.charAt(i-1)==buffer2.charAt(j-1) && i>0 && j>0){mat[i][j]=mat[i-1][j-1]+1;flag[i][j]="left_up";}if(buffer1.charAt(i-1)!=buffer2.charAt(j-1) && i>0 && j>0){mat[i][j]=Math.max(mat[i-1][j], mat[i][j-1]);if(mat[i][j]==mat[i][j-1]) flag[i][j]="left";if(mat[i][j]==mat[i-1][j]) flag[i][j]="up";}}}System.out.println(mat[m][n]);SubSequence(buffer2,flag,m,n);}}

运行结果：(我这里只输出一个结果)

ABCBDAB

BDCABA
4
A B C B

有了上述的基础，相信这个问题就不难了，来，看一下经典的字符串编辑距离的问题：

6.编辑距离，又称Levenshtein距离，是指两个字串之间，由一个转成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。

例如将kitten一字转成sitting：

sitten （k→s）
sittin （e→i）
sitting （→g）

俄罗斯科学家Vladimir Levenshtein在1965年提出这个概念。

问题：找出字符串的编辑距离，即把一个字符串s1最少经过多少步操作变成编程字符串s2，操作有三种，添加一个字符，删除一个字符，修改一个字符

dp[i][j]表示子串str1[0~i]与子串str2[0~j]的编辑距离。状态转移方程为

str[i]==str2[j]时，dp[i][j]=dp[i-1][j-1]；

str[i]≠str2[j]时，dp[i][j]=min(dp[i-1][j],dp[i][j-1],dp[i-1][j-1])+1；

注意边界情况的处理。

import java.util.Scanner;import javax.swing.text.html.MinimalHTMLWriter;public class StringDistance {/** * 计算编辑距离 * @param args */private static int min(int a, int b, int c) {return Math.min(Math.min(a, b),c);}public static void main(String[] args) {// TODO Auto-generated method stubScanner scanner=new Scanner(System.in);String string1=scanner.nextLine();String string2=scanner.nextLine();int m=string1.length();int n=string2.length();int[][] dp=new int[m+1][n+1];//注意数组的长度for (int i = 0; i < dp.length; i++) {dp[i][0]=i;}for (int i = 0; i < dp[0].length; i++) {dp[0][i]=i;}for (int i = 1; i < dp.length; i++) {for (int j = 1; j < dp[0].length; j++) {if(string1.charAt(i-1)==string2.charAt(j-1))dp[i][j]=dp[i-1][j-1];else {dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1,dp[i-1][j-1]+1);}}}for (int i = 0; i < dp.length; i++) {for (int j = 0; j < dp[0].length; j++) {System.out.print(dp[i][j]+" ");}System.out.println();}System.out.println(dp[m][n]);}}

结果：

kitten
sitting
0 1 2 3 4 5 6 7
1 1 2 3 4 5 6 7
2 2 1 2 3 4 5 6
3 3 2 1 2 3 4 5
4 4 3 2 1 2 3 4
5 5 4 3 2 2 3 4
6 6 5 4 3 3 2 3
3

想一想，多有意思，字符串编辑距离居然是另一种形式的“松鼠吃苹果问题”！

在这里的“苹果”是如何定义的？不由感叹，造物之神奇！

1 0