动态规划总结经典题目(经典中的经典)

动态规划总结——经典问题总结

本文着重讨论状态是如何表示，以及方程是怎样表示的。当然，还附上关键的，有可能作为模板的代码段。但有的代码的实现是优化版的。

经典问题总结

最长上升子序列（LIS）

问题描述如下:

设L=是n个不同的实数的序列，L的递增子序列是这样一个子序列Lin=，其中k1

这里采用的是逆向思维的方法，从最后一个开始想起，即先从A[N]（A数组是存放数据的数组，下同）开始，则只有长度为1的子序列，到A[N-1]时就有两种情况，如果a[n-1] < a[n] 则存在长度为2的不下降子序列 a[n-1],a[n]；如果a[n-1] > a[n] 则存在长度为1的不下降子序列a[n-1]或者a[n]。

有了以上的思想，DP方程就呼之欲出了（这里是顺序推的，不是逆序的）：

DP[I]=MAX（1,DP[J]+1） J=0,1,...,I-1

但这样的想法实现起来是）O(n^2)的。本题还有更好的解法，就是O(n*logn)。利用了长升子序列的性质来优化，以下是优化版的代码：

//最长不降子序

const int SIZE=500001;

int data[SIZE];

int dp[SIZE];

//返回值是最长不降子序列的最大长度,复杂度O(N*logN)

int LCS(int n) { //N是DATA数组的长度,下标从1开始

int len(1),low,high,mid,i;

dp[1]=data[1];

for(i=1;i<=n;++i) {

low=1;

high=len;

while( low<=high ) { //二分

mid=(low+high)/2;

if( data[i]>dp[mid] ) {

low=mid+1;

}

else {

high=mid-1;

}

}

dp[low]=data[i];

if( low>len ) {

++len;

}

}

return len;}

最长公共子序列（LCS）

给出两个字符串a, b，求它们的最长、连续的公共字串。

这很容易就想到以DP[I][J]表示A串匹配到I，B串匹配到J时的最大长度。则：

0 I==0 || J==0

DP[I][J]=DP[I-1][J-1]+ 1 A[I]==B[J]

MAX（DP[I-1][J]，DP[I][J-1]）不是以上情况

但这样实现起来的空间复杂度为O(n^2)，而上面的方程只与第I-1行有关，所以可以用两个一维数组来代替。以下是代码：

//最长公共子序列

const int SIZE=1001;

int dp[2][SIZE]; //两个一维数组

//输入两个字符串，返回最大的长度

int LCS(const string& a,const string& b) {

int i,j,flag;

memset(dp,0,sizeof(dp));

flag=1;

for(i=1;i<=a.size();++i) {

for(j=1;j<=b.size();++j) {

if( a[i-1]==b[j-1] ) dp[flag][j]=dp[1-flag][j-1]+1;

else dp[flag][j]=MAX(dp[flag][j-1],dp[1-flag][j]);

}

flag=1-flag;

}

return dp[1-flag][b.size()];

}

01背包

有N件物品和一个容量为V的背包。第i件物品的大小是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。

用DP[I][J] 表示前I件物品放入一个容量为J的背包可以获得的最大价值。则

DP[I][J]= DP[I-1][J] ,J

MAX（DP[I-1][J]，DP[I-1][J-C[I]]+W[I]） , J>=C[I]

这样实现的空间复杂度为O(VN)，实际上可以优化到O（V）。以下是代码：

const int MAXW=13000; //最大重量

const int MAXN=3450; //最大物品数量

int c[MAXN]; //物品的存放要从下标1开始

int w[MAXN]; //物品的存放要从下标1开始

int dp[MAXW];

//不需要将背包装满，则将DP数组全部初始化为0

//要将背包装满，则初始化为DP[0]=0，DP[1]…DP[V]=-1(即非法状态)

int Packet(int n,int v) {

int i,j;

memset(dp,0,sizeof(dp));

for(i=1;i<=n;++i) {

for(j=v;j>=c[i];--j) { //这里是倒序，别弄错了

dp[j]=MAX(dp[j],dp[j-c[i]]+w[i]);

}

}

return dp[v];}

完全背包问题

有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

很容易可以得到这种状态表示：用DP[I][J] 表示前I件物品放入一个容量为J的背包可以获得的最大价值。则

DP[I][J]=MAX（DP[I-1][J]，DP[I-1][J-K*C[I]]+K*W[I]） 0<=K*C[I]<=J

这样的复杂度是O(V*Σ(V/c[i]))

有更好的做法，那就是利用01背包的优化原理。在优化的代码中，之所以第二重循环是倒序，是为了防止重复拿，那么只要将其变为顺序即可以重复取。代码就不给了。

多重背包问题

有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

这题仍然可以用到上一题的思想，DP表示状态与上面的相同。方程为：

DP[I][J]=MAX（DP[I-1][J]，DP[I-1][J-K*C[I]]+K*W[I]）

不同的是K的范围，0<=K<=N[I] && 0<=K*C[I]<=J

这样的复杂度为O(V*Σn[i])。

有更好的想法就是先用二进制来划分。将第i种物品分成若干件物品，其中每件物品有一个系数，这件物品的费用和价值均是原来的费用和价值乘以这个系数。使这些系数分别为

1,2,4,...,2^(k-1),n[i]-2^k+1，且k是满足n[i]-2^k+1>0的最大整数。然后用01背包做，这样的复杂度为O(V*Σlog n[i])。关键代码：

const int SIZE=1001;

int dp[SIZE];

int num[SIZE],c[SIZE],w[SIZE]; //num[i]是I物品的件数,C[I]是费用，W[I]是价值

int MultiPack(int n,int v) { //存入参数，N是物品种类数，V是背包容量

int i,j,k;

memset(dp,0,sizeof(dp));

for(i=1;i<=n;++i) { //存放物品的数组下标从1开始

if( c[i]*num[i]>=v ) {

for(j=c[i];j<=v;++j) {

dp[j]=MAX(dp[j],dp[j-c[i]]+w[i]);

}

}

else { //使用二进制划分

k=1;

while( k

for(j=v;j>=k*c[i];--j) {

dp[j]=MAX(dp[j],dp[j-k*c[i]]+k*w[i]);

}

num[i]-=k;

k*=2;

}

for(j=v;j>=num[i]*c[i];--j) {

dp[j]=MAX(dp[j],dp[j-num[i]*c[i]]+num[i]*w[i]);

}

}

}

return dp[v];

}

状态表示总结

一维的状态表示

DP的表示形式通常为：DP[I]表示取到第I个/种物品时的最优值。DP方程的形式：DP[I]=MAX（DP[I]，DP[J]+P[I]）其中0<=J

DP[I]=DP[I-1]+P[I](即只与I-1有关)

有一些题可能要将一些额外的东西也认为是物品。如HDU2059龟兔赛跑这题，需要将开始点和终点也认为是加油站，然后才以DP[I]表示到第I个加油站并加满油的最短时间。

有一些题可以将看似二维的情况转化为一维的情况来做。如HDU 1081这题。大意是给出一个含有正数和负数的N阶矩阵，求一个子矩阵使得子矩阵内所有数的和最大。这样的题可以将几行合并为一行做。即枚举就将第I行到第J行合并为一行，然后再用DP[K]=MAX（DP[K-1]，0）+ARR[K]，K是表示第K列。

有一些题是DP与暴力相结合，如POJ 3267 The Cow Lexicon这题。大意是给出一个长的字符串，还有若干个短的字符串，问长字符中至少要删除几个字符才能使得长字符串中的子字符串都与某个短字符串相对应。dp[i]表示从I到LEN-1需要删除的最少字符串数，则dp[i]=min(dp[i+1]+1，dp[k]+del)其中dp[i+1]+1是没有找到匹配的情况，dp[k]+del是有匹配的情况,K表示从I开始匹配,到匹配完后的最后一个字符的位置,DEL表示在匹配过程中要删除的字符数。由于方程的特点，要从最后一个字符向第一个字符推去。中间要删除的字符数用暴力找出。

有一些题用DP来枚举全部的范围，如POJ 1925 Spiderman这题。用DP[I]表示到达这个位置的最小跳数。其中DP数组为dp[1000005]，这是可能跳到的全部范围。

二维状态表示

通常是用来处理两种事物。DP[I][J]通常表示A的前I个和B的前J个XX的最优值。

DP方程之一：DP[I][J]=MAX（DP[I-1][J-1]+P[XX]，DP[I][J-1]+P[YY]，

DP[I-1][J]+P[ZZ]）这里的XX，YY，ZZ是表示某某状态得到的结果。

DP方程之二：DP[I][J]=MAX（DP[I][J]，DP[I-1][K]+P[I][J]），其中0<=K

DP方程之三：DP[I][J]=MAX（DP[I+1][J]+P[XX]，DP[I][J-1]+P[YY]）

对第三种DP方程举个例：POJ 3280 Cheapest Palindrome这题。大意是给出一个字符串，你可在任意位置增加或删除字符，每增加或删除一个字符都有一个对应的代价，求将其变为回文串的最小代价。以dp[i][j]表示从i到j要变成回文字符串的最小代价，则

dp[i][j] = min{ dp[i+1][j] + {去掉X的代价}，dp[i+1][j] + {加上X的代价}，

dp[i][j-1]+ {去掉Y的代价}，dp[i][j-1] +{加上Y的代价}}；

算DP[I][J]时，要知道DP[I+1][J]的值，对于这类DP其实现方法如下所示：for(t=1;t

for(i=1;i

if( i+t<=len ) {

j=i+t;

//do your work

}

}

}

有一些题看似一维，可将之变为二维。如：POJ1159 Palindrome这题。大意是给出一个字符，求将其变为回文串要加入的最少字符数。得到字符串后，再构造一个逆串，然后求其LCS。最后将字符串长度减去LCS数就是结果。

有时可以将DP与HASH相结合。如：POJ 1054 The Troublesome Frog这题。大意是在一个坐标系中给出N个点，求找出以哪两点作一条直线经过的点数最多。以DP[I][J]表示过第J点和第I点的直线一共经过的点数。DP[I][J]=（DP[J][INDEX]+1，-INF），先算出INDEX这点的坐标，然后用哈希查找，如果找到，则执行

DP[J][INDEX]+1，如果找不到则用-INF表示不存在。

对于整除类型的题，如果要用DP做，那么其中有一维通常是佘数。如：POJ 1745Divisibility这题，dp[i][j]表示对前I个数进行了处理,余数为J的情况

带偏移的状态表示

DP的表示形式通常为：DP[I][J]表示到第I个XX时，YY与ZZ之差为J时的最优值。例如：POJ 1837这题。

题目大意：给出天平c个挂钩的位置,然后给出g个物品的质量,将物品挂在天平上,问使天平平衡的方法有几种。

思想：用l[i]表示第i个点的x坐标值，用w[i]表示第i个砝码的重量，用dp[i][j]表示加了i个砝码，两边力矩之差为j的可能方法数，则本题只要计算出dp[i][0]，即最终力矩差为0的方法数即可。由于质量差可能为负，这里加上一个偏移量，考虑原题的数据可知，要想平衡，则一边力矩至多为15*25*10=3750，故每个j加上3750。状态转移方程：dp[i+1][k+w[i]*l[j]]+= dp[i][k]，i=0~g，j=0~c，k=0~7500。输出结果：dp[w][3750]

动态规划变态总结by zeus

1：Pku acm 1163 the Triangle

2：Pku acm 1953 World Cup Noise //说白了就是斐波那切数列

3：Pku acm 1458 Common Subsequence Lcs

4：Pku acm 2250 Compromise记录路径的lcs

5：Pku acm 1159 Palindrome 回文串

6：Pku acm 1080 Humman Gene Function

7：Pku acm 2192 Zipper 判断2个字符串能否组成1个字符串

8：Pku acm 3356 AGTC 一个字符串到另一个的最小步骤

9：Pku acm 1887 Testing the CATCHER最长下降子序列

10：Pku acm 2533 Longest Ordered Subsequence最长上升子序列

11：Pku acm 1631 Bridging signals最长上升子序列的加强版….二分法

12：Pku acm 1157 LITTLE SHOP OF FLOWERS

13：Pku acm 1088 滑雪

14：Pku 1050 To the Max

15：Pku 1050 To the Max最大线段和的加强板…..二维的16：Pku 1014 dividing

17: Pku acm 1160 post office

18: pku acm 1015 Jury Compromise

19: hdoj 2546饭卡

20:pku 1837 Balance

21: pku 3267 The Cow Lexicon

22:Pku 1742 Coins

//走塔....经典的dp

#include "iostream"

using namespace std;

int max(int a,int b)

{

return a>b?a:b;

}

int main()

{

int n,i,j;

int a[100][100];

int f[100];

while(scanf("%d",&n)>0)

{

for(i=0;i

for(j=0;j<=i;j++)

{

scanf("%d",&a[i][j]);

if(i==n-1)

f[j]=a[i][j];

}

for(i=n-2;i>=0;i--)

{

for(j=0;j<=n-1;j++)

if(f[j]>f[j+1])

f[j]=f[j]+a[i][j];

else

f[j]=f[j+1]+a[i][j];

}

printf("%d\n",f[0]);

}

system("pause");

}

2：Pku acm 1953 World Cup Noise //说白了就是斐波那切数列

#include "iostream"

using namespace std;

int main()

{

int n,m;

int i;

int f[100];

f[0]=2;

f[1]=3;

scanf("%d",&n);

for(i=2;i<100;i++)

{

f[i]=f[i-1]+f[i-2];

}

for(i=0;i

{

scanf("%d",&m);

{

printf("Scenario #%d:\n%d\n\n",i+1,f[m-1]); }

}

}

3：Pku acm 1458 Common Subsequence Lcs经典

#include "iostream"

#include "cstring"

using namespace std;

int setmax(int a,int b)

{

if(a>b)

return a;

else return b;

}

int f[8100][8100];

main()

{

char s1[800];

char s2[800];

int i,j;

int sl1,sl2;

while(scanf("%s %s",&s1,&s2)!=EOF)

{

sl1=strlen(s1);

sl2=strlen(s2);

for(i=0;i

{

f[0][i]=0;

f[i][0]=0;

}

for(i=1;i

for(j=1;j

{

if(s1[i-1]==s2[j-1])

f[i][j]=f[i-1][j-1]+1;

else

f[i][j]=setmax(f[i-1][j],f[i][j-1]);

}

printf("%d\n",f[i-1][j-1]);

}

}

4：Pku acm 2250 Compromise记录路径的lcs

#include "iostream"

#include "string"

using namespace std;

#define N 100

struct node

{

string s;

}s1[N],s2[N];

int f[N][N];

int path[N][N];

string temp;

int flag;

void lcs(int i,int j)

{

if(i==0||j==0) return ;

if(path[i][j]==1) {

lcs(i-1,j-1);

{

if(flag!=1){

cout<

flag=1;}

else

cout<

}

else

if(path[i][j]==2) lcs(i-1,j);

else lcs(i,j-1);

}

int main()

{

int i=0,j;

int len1,len2;

while(cin>>s1[0].s)

{

memset(f,0,sizeof(f));

i=1;

while(1){

cin>>temp;

if(temp=="#") break;

s1[i++].s=temp;

}

len1=i;

i=0;

while(1){

cin>>temp;

if(temp=="#") break;

s2[i++].s=temp;

}

len2=i;

memset(path,0,sizeof(path));

for(i=0;i<=len1;i++)

for(j=0;j<=len2;j++)

if(i==j) f[i][j]=1;

for(i=1;i<=len1;i++)

for(j=1;j<=len2;j++)

{

if(s1[i-1].s==s2[j-1].s)

{

f[i][j]=f[i-1][j-1]+1;

path[i][j]=1;

}

else if(f[i-1][j]>=f[i][j-1])

{

f[i][j]=f[i-1][j];

path[i][j]=2;

}

else

{

f[i][j]=f[i][j-1];

path[i][j]=3;

}

}

flag=1;

lcs(len1,len2);

cout<

}

}

5：Pku acm 1159 Palindrome 回文串

带有些许优化的lcs

#include "iostream"

#include "string"

#include "algorithm"

using namespace std;

int a[5005],b[5005];

int c[3],d[3];

string s1,s2;

int main()

{

int m,n=0;

int i,j;

while(cin>>n)

{

if(n==0) break;

cin>>s1;

s2=s1;

reverse(s2.begin(),s2.end());

memset(a,0,sizeof(a));

memset(b,0,sizeof(b));

for(i=0;i

{

b[0]=0;

for(j=0;j

{

if(s1[i]==s2[j])

{

b[j+1]=a[j]+1;

}

else if(b[j]>a[j+1])

{

b[j+1]=b[j];

}

else if(b[j]

{

b[j+1]=a[j+1];

}

}

for(j=0;j<=n;j++)

a[j]=b[j];

}

printf("%d\n",n-b[n]);

}

}

6：Pku acm 1080 Humman Gene Function

#include "iostream"

using namespace std;

int f[250][250];

int g[250][250];

char s1[180];

char s2[180];

int maxnum(int x,int y,int z)

{

int zz= x>y?x:y;

return zz>z?zz:z;

}

void make()

{

f[1][1]=5;f[1][2]=-1;f[1][3]=-2;f[1][4]=-1;f[1][5]=-3;

f[2][1]=-1;f[2][2]=5;f[2][3]=-3;f[2][4]=-2;f[2][5]=-4;

f[3][1]=-2;f[3][2]=-3;f[3][3]=5;f[3][4]=-2;f[3][5]=-2;

f[4][1]=-1;f[4][2]=-2;f[4][3]=-2;f[4][4]=5;f[4][5]=-1;

f[5][1]=-3;f[5][2]=-4;f[5][3]=-2;f[5][4]=-1;f[5][5]=-99999; }

int sw(char ch)

{

if(ch=='A') return 1;

else if(ch=='C') return 2;

else if(ch=='G') return 3;

else if(ch=='T') return 4;

else if(ch=='-') return 5;

}

int find(char ch1,char ch2)

{

return f[sw(ch1)][sw(ch2)];

}

int main()

{

make();

int sl1,sl2,i,j,m;

memset(g,0,sizeof(0));

cin>>m;

while(m--)

{

cin>>sl1;

cin>>s1;

cin>>sl2;

cin>>s2;

for(i=1;i<=sl2;i++)

g[0][i] = g[0][i-1]+find('-',s2[i-1]);

for(i=1;i<=sl1;i++)

g[i][0] = g[i-1][0]+find(s1[i-1],'-');

for(i=1;i<=sl1;i++)

for(j=1;j<=sl2;j++)

{

g[i][j]=maxnum(g[i][j-1]+find('-',s2[j-1]),g[i-1][j]+find(s1[i-1],'-'),g[i-1][j-1]+find(s1[i-1],s2[j-1]));

}

cout<

}

}

7：Pku acm 2192 Zipper 判断2个字符串能否组成1个字符串

//用动态规划解决，ok[i][j]表示str1长度为i的前缀和str2长度为j的后缀能否组成目标中str中长度为i+j的前缀串

#include "iostream"

using namespace std;

int i,j,n;

int sl1,sl2,sl3;

char s1[500],s2[500],s3[500];

int f[500][500];

int main()

{

int count=0;

scanf("%d",&n);

while(n--)

{count++;

memset(f,0,sizeof(f));

scanf("%s %s %s",s1,s2,s3);

sl1=strlen(s1);

sl2=strlen(s2);

sl3=strlen(s3);

for(j=0;j

{

if(s1[j]==s3[j])

f[j+1][0]=1;

else

break;

}

for(i=0;i

{

if(s2[i]==s3[i])

f[0][i+1]=1;

else

break;

}

for(i=0;i<=sl1;i++)

for(j=0;j<=sl2;j++)

{

if(!(i==0&&j==0))

if(s1[i]==s3[i+j]&&f[i][j]==1)

f[i+1][j]=1;

if(s2[j]==s3[i+j]&&f[i][j]==1)

f[i][j+1]=1;

}

printf("Data set %d: ",count);

if(f[sl1][sl2]==1)

printf("yes\n");

else

printf("no\n");

}

}

8：Pku acm 3356 AGTC 一个字符串到另一个的最小步骤

#include "iostream"

#include "string"

using namespace std;

int setmin(int x,int y,int z)

{

int xx=x>y?y:x;

return xx>z?z:xx;

}

string s1,s2;

int f[1005][1005];

int main()

{

int n,m;

int i,j;

while(cin>>n)

{

cin>>s1;

cin>>m;

cin>>s2;

for(i=0;i<=n;i++)

f[i][0]=i;

for(i=0;i<=m;i++)

f[0][i]=i;

for(i=1;i<=n;i++)

for(j=1;j<=m;j++)

{

if(s1[i-1]==s2[j-1])

f[i][j]=setmin(f[i-1][j]+1,f[i][j-1]+1,f[i-1][j-1]);

else

f[i][j]=setmin(f[i-1][j]+1,f[i][j-1]+1,f[i-1][j-1]+1);

}

cout<

}

}

9：Pku acm 1887 Testing the CATCHER最长下降子序列

#include "iostream"

using namespace std;

int a[32769],f[32769];

int main()

{

int i,j,n,max;

int count=0;

while(1)

{ count++;

scanf("%d",&a[0]);

if(a[0]==-1) break;

i=1;

while(1)

{

scanf("%d",&a[i]);

if(a[i]==-1)

break;

i++;

}

n=i;

max=0;

memset(f,0,sizeof(f));

for(i=1;i<=n;i++)

{ f[i]=1;

for(j=0;j<=i;j++)

{

if(a[j-1]>a[i-1]&&f[j]+1>f[i])

f[i]=f[j]+1;

if(f[i]>max)

max=f[i];

}

}

printf("Test #%d:\n",count);

printf(" maximum possible interceptions: %d\n\n",max);

}

}

10：Pku acm 2533 Longest Ordered Subsequence最长上升子序列

#include "iostream"

using namespace std;

int f[10000];

int a[10000];

int main()

{

int n,i,j,max;

while(scanf("%d",&n)!=EOF)

{

for(i=0;i

{

scanf("%d",&a[i]);

}

memset(f,0,sizeof(f));

max=0;

for(i=1;i<=n;i++)

{

f[i]=1;

for(j=0;j<=i;j++)

if(a[j-1]f[i])

f[i]=f[j]+1;

if(f[i]>max)

max=f[i];

}

printf("%d\n",max);

}

}

11：Pku acm 1631 Bridging signals最长上升子序列的加强版….二分法

#include "iostream"

#include "string"

using namespace std;

#define N 50000

int f[N];

int a[N];

int main()

{

int n,m,i,j,max;

scanf("%d",&n);

while(n--)

{

max=-99;

memset(f,0,sizeof(f));

scanf("%d",&m);

for(i=0;i

{

scanf("%d",&a[i]);

// f[i]=a[i];

}

f[1]=a[0];

int s=1;

int l,r,mid;

for(i=1;i

{