Java算法-动态规划详解

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java算法-动态规划详解相关的知识,希望对你有一定的参考价值。

 

什么是动态规划?

        动态规划(Dynamic Programming,所以我们简称动态规划为DP)是运筹学的一个分支,是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时,提出了著名的最优化原理(principle of optimality),把多阶段过程转化为一系列单阶段问题,利用各阶段之间的关系,逐个求解,创立了解决这类过程优化问题的新方法——动态规划。1957年出版了他的名著《Dynamic Programming》,这是该领域的第一本著作。

       动态规划算法通常基于一个递推公式及一个或多个初始状态。当前子问题的解将由上一次子问题的解推出。使用动态规划来解题只需要多项式时间复杂度,因此它比回溯法、暴力法等要快许多。

       说了这么多术语,想必大家都很头疼,现在让我们通过一个例子来了解一下DP的基本原理。

首先,我们要找到某个状态的最优解,然后在它的帮助下,找到下一个状态的最优解。这句话暂时理解不了没关系,请看下面的例子:

如果我们有面值为1元、3元和5元的硬币若干枚,如何用最少的硬币凑够11元? 

我们凭直观感觉告诉自己,先选面值最大,因此最多选2枚5元的硬币,现在是10元了,还差一元,接下来我们挑选第二大的3元硬币,发现不行(10+3=13超了),因此我们继续选第三大的硬币也就是1元硬币,选一个就可以(10+1=11),所以总共用了3枚硬币凑够了11元。这就是贪心法,每次选最大的。但是我们将面值改为2元,3元和5元的硬币,再用贪心法就不行了。为什么呢?按照贪心思路,我们同样先取2枚最大5元硬币,现在10元了,还差一元,接下来选第二大的,发现不行,再选第三大的,还是不行,这时用贪心方法永远凑不出11元,但是你仔细看看,其实我们可以凑出11元的,2枚3元硬币和1枚五元硬币就行了,这是人经过思考判断出来了的,但是怎么让计算机算出来呢?这就要用动态规划的思想:

首先我们思考一个问题,如何用最少的硬币凑够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-vj)+1 },其中i-vj >=0,vj表示第j个硬币的面值;

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

 

  1. int main()  
  2. {  
  3.     int a[3] = {1,3,5},sum = 11,cent = 0,dp[12];  
  4.     dp[0] = 0;  
  5.     for(int i = 1; i <= sum; i++) dp[i] = i;//我们假设存在1元的硬币那么i元最多只需要i枚1元硬币,当然最好设置dp[i]等于无穷大  
  6.    
  7.     for(int i = 1; i <= sum; i++){  
  8.         for(int j = 0; j < 3; j++){  
  9.             if(i >= a[j] && dp[i - a[j]] + 1 < dp[i]){  
  10.                 dp[i] = dp[i- a[j] ] + 1;  
  11.             }  
  12.         }  
  13.     }  
  14.     cout<<dp[sum]<<endl;  
  15.     return 0;  
  16. }  


 

 

下图是当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元。

 

    通过硬币问题我们初识DP的原理,其实可以说贪心问题是DP问题的特例,现在我们通过几道题目加深对DP问题的理解

数塔问题是动态规划经典的题目,下面来初步讲解下

将一个由N行数字组成的三角形,如图所以,设计一个算法,计算出三角形的由顶至底的一条路径,使该路径经过的数字总和最大。

学弟学妹们你们之前学过DFS和BFS,第一眼看过去这题应该用DFS解决,没错,DFS也可以,但是我们观察下n行总共有(1 + 2 + 3 + 4+...+n) = (1+n)*n/2个节点,在递归求解的过程中很多节点被重复访问了,这就导致时间大大增加,必然超时

比如用递归的话,18这个节点被访问了两次

 技术分享

但是如果用DP的话这个节点可以只访问一次

 

 技术分享

好了,现在我们用DP解决这道问题

技术分享

 

将上图转化一下:

技术分享

 

假设上图用map[][]数组保存。

令f[i][j]表示从顶点(1, 1)到顶点(i, j)的最大值。

则可以得到状态转移方程:

f[i][j] = max(f[i+1][j], f[i+1][j+1]) + map[i][j]

此题既适合自顶而下的方法做,也适合自底而上的方法,

当用自顶而下的方法做时,最后要在在最后一列数中找出最大值,

而用自底而上的方法做时,f[1][1]即为最大值。

所以我们将图2根据状态转移方程可以得到图3:

技术分享

 

最大值是30.

代码如下:

 

  1. 1 #include <cstdio>    
  2. 2. #include <iostream>    
  3. 3. #include <algorithm>    
  4. 4. #include <cstring>    
  5. 5. using namespace std;    
  6. 6. int a[2000][2000];    
  7. 7. int main()    
  8. 8. {    
  9. 9.     int t,n,i,j;    
  10. 10.     while(~scanf("%d",&n))    
  11. 11.     {   
  12. 12.         for(i=0; i<n; i++)    
  13. 13.             for(j=0; j<=i; j++)    
  14. 14.                 scanf("%d",&a[i][j]);    
  15. 15.         for(i=n-1; i>0; i--)    
  16. 16.             for(j=0; j<i; j++)    
  17. 17.                 a[i-1][j]+=max(a[i][j],a[i][j+1]);    
  18. 18.         printf("%d\n",a[0][0]);    
  19. 19.     }    
  20. 20.     return 0;    
  21. 21. }    


 

 

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

OK,上例子,看看它是如何工作的。

一个序列有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序列)

 

 技术分享

代码:

 

  1. 1. #include <cstdio>    
  2. 2. #include <iostream>    
  3. 3. #include <algorithm>    
  4. 4. #include <cstring>    
  5. 5. usingnamespace std;    
  6. 6.      
  7. 7. int main()    
  8. 8. {    
  9. 9.     int dp[2000],a[2000],n;    
  10. 10.     while(cin>>n)    
  11. 11.     {    
  12. 12.         memset(dp,0,sizeof(dp));    
  13. 13.         intres = 0;    
  14. 14.         for(inti = 0; i < n; i++) cin>>a[i];    
  15. 15.      
  16. 16.         for(inti = 0; i < n; i++)    
  17. 17.         {    
  18. 18.             dp[i] = 1;    
  19. 19.             for(intj = 0; j < i; j++)    
  20. 20.             {    
  21. 21.                 if(a[j] < a[i])    
  22. 22.                 dp[i] = max(dp[i],dp[j] + 1);    
  23. 23.             }    
  24. 24.      
  25. 25.           res = max(res,dp[i]);    
  26. 26.         }    
  27. 27.      
  28. 28.         cout<<res<<endl;    
  29. 29.     }    
  30. 30.     return0;    
  31. 31. }  


 

该算法的时间复杂度是O(n2 ),并不是最优的解法。还有一种很巧妙的算法可以将时间复杂度降到O(nlogn),网上已经有各种文章介绍它,这里就不再赘述。此题还可以用“排序+LCS”来解,感兴趣的话可自行Google,Baidu。

 

最后讲一下最长上升公共子序列问题:

问题描述

    什么是最长公共子序列呢?好比一个数列S,如果分别是两个或多个已知数列的子序列,且是所有符合此条件序列中最长的,则S 称为已知序列的最长公共子序列。

    举个例子,如:有两条随机序列,如 1 3 4 5 5 ,and 2 4 5 5 7 6,则它们的最长公共子序列便是:4 5 5。

LCS问题的解决思路

· 

穷举法   

· 

    解最长公共子序列问题时最容易想到的算法是穷举搜索法,即对X的每一个子序列,检查它是否也是Y的子序列,从而确定它是否为X和Y的公共子序列,并且在检查过程中选出最长的公共子序列。X和Y的所有子序列都检查过后即可求出X和Y的最长公共子序列。X的一个子序列相应于下标序列{1, 2, …, m}的一个子序列,因此,X共有2m个不同子序列(Y亦如此,如为2^n),从而穷举搜索法需要指数时间(2^m * 2^n)。

· 动态规划算法

    事实上,最长公共子序列问题也有最优子结构性质。

记:

Xi=﹤x1,?,xi﹥即X序列的前i个字符 (1≤i≤m)(前缀)

Yj=﹤y1,?,yj﹥即Y序列的前j个字符 (1≤j≤n)(前缀)

假定Z=﹤z1,?,zk﹥∈LCS(X , Y)。

· 

若xm=yn(最后一个字符相同),则不难用反证法证明:该字符必是X与Y的任一最长公共子序列Z(设长度为k)的最后一个字符,即有zk = xm = yn 且显然有Zk-1∈LCS(Xm-1 , Yn-1)即Z的前缀Zk-1是Xm-1与Yn-1的最长公共子序列。此时,问题化归成求Xm-1与Yn-1的LCS(LCS(X , Y)的长度等于LCS(Xm-1 , Yn-1)的长度加1)。

· 

· 

若xm≠yn,则亦不难用反证法证明:要么Z∈LCS(Xm-1, Y),要么Z∈LCS(X , Yn-1)。由于zk≠xm与zk≠yn其中至少有一个必成立,若zk≠xm则有Z∈LCS(Xm-1 , Y),类似的,若zk≠yn 则有Z∈LCS(X , Yn-1)。此时,问题化归成求Xm-1与Y的LCS及X与Yn-1的LCS。LCS(X , Y)的长度为:max{LCS(Xm-1 , Y)的长度, LCS(X , Yn-1)的长度}。

· 

    由于上述当xm≠yn的情况中,求LCS(Xm-1 , Y)的长度与LCS(X , Yn-1)的长度,这两个问题不是相互独立的:两者都需要求LCS(Xm-1,Yn-1)的长度。另外两个序列的LCS中包含了两个序列的前缀的LCS,故问题具有最优子结构性质考虑用动态规划法。

    也就是说,解决这个LCS问题,你要求三个方面的东西:1、LCS(Xm-1,Yn-1)+1;2、LCS(Xm-1,Y),LCS(X,Yn-1);3、max{LCS(Xm-1,Y),LCS(X,Yn-1)}。

    行文至此,其实对这个LCS的动态规划解法已叙述殆尽,不过,为了成书的某种必要性,下面,我试着再多加详细阐述这个问题。

第三节、动态规划算法解LCS问题

3.1、最长公共子序列的结构

    最长公共子序列的结构有如下表示:

    设序列X=<x1, x2, …, xm>和Y=<y1, y2, …, yn>的一个最长公共子序列Z=<z1, z2, …, zk>,则:

1. 若xm=yn,则zk=xm=yn且Zk-1是Xm-1和Yn-1的最长公共子序列;

2. 若xm≠yn且zk≠xm ,则Z是Xm-1和Y的最长公共子序列;

3. 若xm≠yn且zk≠yn ,则Z是X和Yn-1的最长公共子序列。

    其中Xm-1=<x1, x2, …, xm-1>,Yn-1=<y1, y2, …, yn-1>,Zk-1=<z1, z2, …, zk-1>。

3、2.子问题的递归结构

    由最长公共子序列问题的最优子结构性质可知,要找出X=<x1, x2, …, xm>和Y=<y1, y2, …, yn>的最长公共子序列,可按以下方式递归地进行:当xm=yn时,找出Xm-1和Yn-1的最长公共子序列,然后在其尾部加上xm(=yn)即可得X和Y的一个最长公共子序列。当xm≠yn时,必须解两个子问题,即找出Xm-1和Y的一个最长公共子序列及X和Yn-1的一个最长公共子序列。这两个公共子序列中较长者即为X和Y的一个最长公共子序列。

    由此递归结构容易看到最长公共子序列问题具有子问题重叠性质。例如,在计算X和Y的最长公共子序列时,可能要计算出X和Yn-1及Xm-1和Y的最长公共子序列。而这两个子问题都包含一个公共子问题,即计算Xm-1和Yn-1的最长公共子序列。

    与矩阵连乘积最优计算次序问题类似,我们来建立子问题的最优值的递归关系。用c[i,j]记录序列Xi和Yj的最长公共子序列的长度。其中Xi=<x1, x2, …, xi>,Yj=<y1, y2, …, yj>。当i=0或j=0时,空序列是Xi和Yj的最长公共子序列,故c[i,j]=0。其他情况下,由定理可建立递归关系如下:

 

代码如下:

 

  1. 1. #include <cstdio>    
  2. 2. #include <iostream>    
  3. 3. #include <algorithm>    
  4. 4. #include <cstring>    
  5. 5. using namespace std;    
  6. 6.      
  7. 7. int main()    
  8. 8. {    
  9. 9.     string str1,str2;    
  10. 10.     int dp[200][200];    
  11. 11.     while(cin>>str1>>str2)    
  12. 12.     {    
  13. 13.         memset(dp,0,sizeof(dp));    
  14. 14.      
  15. 15.         int la = str1.length();    
  16. 16.         int lb = str2.length();    
  17. 17.      
  18. 18.         for(int i = 1; i <= la; i++)    
  19. 19.             for(int j = 1; j <= lb; j++)    
  20. 20.         {    
  21. 21.             if(str1[i - 1] == str2[j - 1])    
  22. 22.             {    
  23. 23.                 dp[i][j] = dp[i-1][j-1]+1;    
  24. 24.             }    
  25. 25.             else dp[i][j] = max(dp[i-1][j],dp[i][j-1]);    
  26. 26.         }    
  27. 27.         cout<<dp[la][lb]<<endl;    
  28. 28.     }    
  29. 29.     return 0;  


 

 

讲到这想必对DP问题有一个大概的认识了吧?乘热打铁,我们去HDU刷几道简单题练练手感!

 

HDU2191

HDU1159

HDU1432

HDU2084

DP问题是ACM里面最难的,因为太考思维能力了,只有将状态转移方程推出来才能解决问题,DP问题也是面试的时候最容易考到的,希望大家好好学DP,至少在面试的时候不吃亏。

DP问题还有比较难的,分为数字DP,插头DP,状态压缩DP,概率DP,组合DP,树状DP等等都是非常难理解的,但是也很有趣,有兴趣的可以找资料学习

 

最近李建中老师的算法课上完了,他的课大部分都是在讲算法的数学证明,这对算法本身的理解并没有花大手笔,于是我结合自己ACM一年多的算法经验和一堆收集的资料,准备写专题【白话数据结构和算法】,大家多多关注,一起加油~~~~









以上是关于Java算法-动态规划详解的主要内容,如果未能解决你的问题,请参考以下文章

关于动态规划算法,哪位可以讲一下自己心得体会?

Python之动态规划算法

算法题套路总结(三)——动态规划

Python算法-动态规划(Dynamic Programming)

详解三道一维的动态规划算法题

动态规划之 KMP 算法详解