前言：这两天没有写什么题目，把前两周做的有些意思的背包题和最长递增、公共子序列写了个总结。反过去写总结，总能让自己有一番收获......就区间dp来说，一开始我完全不明白它是怎么应用的，甚至于看解题报告都看不明白，而到了现在，遇到区间dp之类的题目，我不至于没有任何方向，慢慢的推导，有些题目没有自己想象的那么难，还是可以推导出转移方程的，有些题目，在自己推导过后，与解题报告相对照，也总能有一番全新的收获。我是觉得，解题报告需要看，但是怎么看，如何看，却是值得思量.......
1、Light oj 1422 Halloween Costumes
题意：给你n天需要穿的衣服的样式，每次可以套着穿衣服，脱掉的衣服就不能再用了（可以再穿），问至少要带多少条衣服才能参加所有宴会
http://lightoj.com/volume_showproblem.php?problem=1422
思路：首先dp[i][j]代表从区间i到区间j需要的最少穿衣服数量，我采取的是从下向上更新的。那么，面临第i件衣服，首先我们考虑穿上它，那么它所在的区间dp[i][j]=dp[i+1][j]+1；
接着考虑是否可以不用穿上它？在什么条件下，可以不用穿这件衣服呢？只有当区间i+1~~j里面已经穿过这件衣服的时候，就可以考虑不用再穿这件衣服。那么假设i+1<=k<=j
其中第k件衣服与第i件一样，那么第k件衣服穿上，第i件衣服不穿的情况的最少穿衣数==dp[i+1][k-1]+dp[k][j]；第i件衣服不穿，那么就从第i+1件衣服开始计算，第k件衣服存在，那么在这个断点，我们该怎么判断是dp[i+1][k-1]+dp[k][j]呢？可以直接从数据推导出这个关系，也可以这样，在第k区间的时候，a[k]可能不是它自己本身穿的，而是在第k区间到第j区间，存在一个k<tmp<=j，有a[tmp]==a[k]......所以会是dp[i+1][k-1]+dp[k][j]........
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int min(int x,int y)
{
if(x>y)
return y;
else
return x;
}
int dp[105][105],a[105];
int main()
{
int text,h=0;
scanf("%d",&text);
while(text--)
{
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
memset(dp,0,sizeof(dp));
for(int i=1;i<=n;i++)
dp[i][i]=1;
for(int i=n-1;i>=1;i--)
{
for(int j=i+1;j<=n;j++)
{
dp[i][j]=dp[i+1][j]+1;
for(int k=i+1;k<=j;k++)
if(a[i]==a[k])
{
dp[i][j]=min(dp[i][j],dp[i+1][k-1]+dp[k][j]);
}
}
}
printf("Case %d: %d\n",++h,dp[1][n]);
}
return 0;
}
2、 poj2955（括号匹配问题）
题意：给你一串()[]括号，要你求出这串括号的最大匹配个数，如'('与')'匹配，为2个，'['与']'匹配，为2个，其他不能匹配.......
思路：dp[i][j]代表从区间i到区间j所匹配的括号的最大个数，首先，假设不匹配，那么dp[i][j]=dp[i+1][j]；然后查找i+1~~j有木有与第i个括号匹配的
有的话，dp[i][j]=max(dp[i][j],dp[i+1][k-1]+dp[k][j]+2).....
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std; int dp[105][105];
char a[105];
int max(int x,int y)
{
if(x>y)
return x;
else return y;
}
int main()
{
while(scanf("%s",a+1)>0&&a[1]!='e')
{
a[0]=2;
int len=strlen(a);
len--;
//printf("%d\n\n",len);
//for(int i=1;i<=len;i++)
//printf("%d %c\n",i,a[i]);
memset(dp,0,sizeof(dp));
for(int i=len-1;i>=1;i--)
{
for(int j=i+1;j<=len;j++)
{
dp[i][j]=dp[i+1][j];
for(int k=i+1;k<=j;k++)
{
if((a[i]=='('&&a[k]==')')||(a[i]=='['&&a[k]==']'))
{
dp[i][j]=max(dp[i][j],dp[i+1][k-1]+dp[k][j]+2);
//printf("%d %d %c %c\n",i,k,a[i],a[k]);
}
}
}
}
printf("%d\n",dp[1][len]);
}
return 0;
}
3、poj3280（推荐）
题意：给你m个字符，其中有n种字符，每种字符都有两个值，分别是增加一个这样的字符的代价，删除一个这样的字符的代价，让你求将原先给出的那串字符变成回文串的最小代价。
思路：dp[i][j]代表区间i到区间j成为回文串的最小代价，那么对于dp[i][j]有三种情况：
1、dp[i+1][j]表示区间i到区间j已经是回文串了的最小代价，那么对于s[i]这个字母，我们有两种操作，删除与添加，对应有两种代价，dp[i+1][j]+add[s[i]],dp[i+1][j]+del[s[i]]，取这两种代价的最小值；
2、dp[i][j-1]表示区间i到区间j-1已经是回文串了的最小代价，那么对于s[j]这个字母，同样有两种操作，dp[i][j-1]+add[s[j]],dp[i][j-1]+del[s[j]]，取最小值
3、若是s[i]==s[j]，dp[i+1][j-1]表示区间i+1到区间j-1已经是回文串的最小代价，那么对于这种情况，我们考虑dp[i][j]与dp[i+1][j-1]的大小........
然后dp[i][j]取上面这些情况的最小值.........
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dp[2005][2005],add[27],del[27];
char s[2005];
int min(int x,int y)
{
if(x>y)
return y;
else
return x;
}
int main()
{
int n,m;
while(scanf("%d%d",&n,&m)>0)
{
scanf("%s",s+1);
s[0]=2;
for(int i=1;i<=n;i++)
{
char ch[10];
int tmp1,tmp2;
scanf("%s%d%d",ch,&tmp1,&tmp2);
add[ch[0]-'a'+1]=tmp1;
del[ch[0]-'a'+1]=tmp2;
}
memset(dp,0,sizeof(dp));
for(int i=m-1;i>=1;i--)
{
for(int j=i+1;j<=m;j++)
{
dp[i][j]=min(dp[i+1][j]+add[s[i]-'a'+1],dp[i+1][j]+del[s[i]-'a'+1]);
int tmp=min(dp[i][j-1]+add[s[j]-'a'+1],dp[i][j-1]+del[s[j]-'a'+1]);
dp[i][j]=min(dp[i][j],tmp);
if(s[i]==s[j])
dp[i][j]=min(dp[i][j],dp[i+1][j-1]);
}
}
printf("%d\n",dp[1][m]);
}
return 0;
}
4、poj1141（区间dp记录路径问题）
题意：给出一串括号，要你补上最少的括号使这一串括号都匹配........
思路：dp[i][j]表示从区间i到区间j使其所以括号匹配需要补上的最少括号数，那么当出现一个括号时，首先考虑它不与后面匹配的情况，那么需要加一个相对应的括号，让之匹配dp[i][j]=dp[i+1][j]+1;
然后再考虑，若是后面有括号可以让它匹配的情况，那么假设i<k<=j，当s[i]=='('&&s[k]==')'的时候，考虑动态转移，dp[i][j]=dp[i+1][k-1]+dp[k][j]-1
为什么这个动态方程减1呢，因为我将与之匹配的那个括号重新计算了一次，当s[k]==')'的时候，在计算dp[k][k]的时候，我的状态转移已经把这个括号自动匹配了一次，所以要减去这次匹配的........
然后就是记录路径了，开一个二维数组a[i][j]，当a[i][j]==-1的时候，表示dp[i][j]这个状态是从dp[i+1][j]推导过来的，当a[i][j]>0的时候，表示dp[i][j]是从dp[i+1][a[i][j]-1]以及dp[k][j]这两个状态推导过来的，那么注意到当a[i][j]！=-1的时候，就正好表示s[i]与s[a[i][j]]匹配，说明在第i个括号这个地方只需要输出它自己本身，其他的，若是a[i][j]==-1的，都需要输出它自身以及与它自身匹配的括号.........
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dp[300][300],a[300][300],b[300];
char s[300];
void print(int i,int j)
{
if(i>=j)
return;
if(a[i][j]==-1)
print(i+1,j);
if(a[i][j]>0)
{
b[i]=1;
b[a[i][j]]=1;
print(i+1,a[i][j]-1);
print(a[i][j],j);
}
}
int main()
{
while(gets(s+1)>0) //这里注意，有直接输入\n的情况.........
{
s[0]=2;
memset(dp,0,sizeof(dp));
memset(a,-1,sizeof(a));
memset(b,0,sizeof(b));
int len=strlen(s);
len--;
for(int i=1;i<=len;i++)
dp[i][i]=1;
for(int i=len-1;i>=1;i--)
{
for(int j=i+1;j<=len;j++)
{
dp[i][j]=dp[i+1][j]+1;
a[i][j]=-1;
for(int k=i+1;k<=j;k++)
if((s[i]=='('&&s[k]==')')||(s[i]=='['&&s[k]==']'))
{
if(dp[i][j]>dp[i+1][k-1]+dp[k][j]-1)
{
dp[i][j]=dp[i+1][k-1]+dp[k][j]-1;
a[i][j]=k;
}
}
}
}
print(1,len);
for(int i=1;i<=len;i++)
{
if(b[i]==1)
printf("%c",s[i]);
else
{
if(s[i]=='('||s[i]==')')
printf("()");
else
printf("[]");
}
}
printf("\n");
}
return 0;
}
5、poj1651（推荐）
题意：给你一组数字，第一个和最后一个数字不可以取出去，其它任意取出去，当你要取出一个数字时，它有一个代价，这个代价就是与它相邻的两个数的乘积，求除了首位两位数字，把其他数字都取出来，它们的代价之和的最小值........
思路：这题目，只有自己做过才能体会......我是说不出来......
Sample Input
6
10 1 50 50 20 5
Sample Output
3650
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dp[105][105],a[105];
int min(int x,int y)
{
if(x>y)
return y;
else
return x;
}
int main()
{
int n;
while(scanf("%d",&n)>0)
{
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
memset(dp,0,sizeof(dp));
for(int i=n-2;i>=1;i--)
{
dp[i][i+2]=a[i]*a[i+1]*a[i+2];
for(int j=i+3;j<=n;j++)
{
dp[i][j]=a[i]*a[i+1]*a[j]+dp[i+1][j];
dp[i][j]=min(dp[i][j],a[i]*a[j-1]*a[j]+dp[i][j-1]);
for(int k=i+2;k<j-1;k++)
dp[i][j]=min(a[i]*a[k]*a[j]+dp[i][k]+dp[k][j],dp[i][j]);
}
}
printf("%d\n",dp[1][n]);
}
return 0;
}
6、poj3661（推荐）
题意：给你一个n,m，n表示有n分钟，每i分钟对应的是第i分钟能跑的距离，m代表最大疲劳度，每跑一分钟疲劳度+1，当疲劳度==m，必须休息，在任意时刻都可以选择休息，如果选择休息，那么必须休息到疲劳度为0，当然，当疲劳度为0的时候也是可以继续选择休息的，求在n分钟后疲劳度为0所跑的最大距离
思路：dp[i][j]表示在第i分钟疲劳度为j的时候所跑的最大距离，dp[i][j]=dp[i-1][j-1]+d[i]；这个转移，说的是，第i分钟选择跑步，当然,第i分钟可以选择不跑步，那么就是选择休息，题目说了，选择休息的话必须要休息到疲劳度为0才可以跑，那还有一点，当疲劳度为0了，还是选择继续休息呢？dp[i][0]=dp[i-1][0]；
选择休息，那么疲劳度到0了，这一点的最大距离怎么做呢？dp[i][0]=max(dp[i][0],dp[i-k][k]) （0<k<=m&&i-k>0）
这样所有的状态都考虑完了，可以写代码了.......
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dp[10005][505],a[10005];
int main()
{
int n,m;
while(scanf("%d%d",&n,&m)>0)
{
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
memset(dp,0,sizeof(dp));
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
dp[i][j]=dp[i-1][j-1]+a[i];
dp[i][0]=dp[i-1][0];
for(int k=1;k<=m;k++)
if(i-k>=0)
dp[i][0]=max(dp[i][0],dp[i-k][k]);
}
printf("%d\n",dp[n][0]);
}
return 0;
}
7、hdu2476(推荐)
给出两串字符，要你将第一串字符变成第二串字符，每次可以改变连续的一个或多个字符，求最少的修改次数
思路：还是区间dp问题，说起来也挺简单的，只是记录路径问题，有些难以想到..........
#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dp[105][105],a[105];
char s[105],t[105];
int main()
{
while(scanf("%s",s+1)>0)
{
scanf("%s",t+1);
s[0]=t[0]=2;
int len=strlen(s);
len--;
memset(dp,0,sizeof(dp));
memset(a,0,sizeof(a));
for(int i=1;i<=len;i++)
dp[i][i]=1;
for(int i=len-1;i>=1;i--)
{
for(int j=i+1;j<=len;j++)
{
//if(s[i]!=t[i])
dp[i][j]=dp[i+1][j]+1;
for(int k=i+1;k<=j;k++)
if(t[i]==t[k])
{
dp[i][j]=min(dp[i][j],dp[i+1][k-1]+dp[k][j]);
}
}
}
for(int i=1;i<=len;i++)
{
a[i]=dp[1][i];
if(s[i]==t[i])
{
if(i==1)
a[i]=0;
else
a[i]=a[i-1];
}
else
for(int j=1;j<i;j++)
a[i]=min(a[i],a[j]+dp[j+1][i]); }
printf("%d\n",a[len]); //printf("%d\n",dp[1][len]);
}
return 0;
}
8、zoj3537（最优三角划分）
9、编辑距离问题
题目描述：
要求两字符串有差异的字符个数。例如：
aaaaabaaaaa
aaaaacaabaa
这两个字符串，最大公共字串长度是5，但它们只有两个字符不同，函数输出值应为2。
如果是：
aaabbbcccddd
aaaeeeddd
函数的输出值应该是6。
比较形象地形容一下，把两个字符串排成上下两行，每个字符串都可以在任何位置插入空格以便上下对齐，每个列上至少有一个字符来自这两个字符串。当对齐程度最高的时候，没有对上的列的数即为函数输出值。
aaabbbcccddd
aaaeeeddd
最优对齐状态是：
aaabbbcccddd
aaaeee ddd
没有对上的列是6，函数输出值为6。
如果是：
abcde
acefg
最优对齐状态是：
abcde
a c efg
没有对上的列数是4，函数输出值为4。
问题抽象归类：（编辑距离问题）
设A和B是2个字符串。要用最少的字符操作将字符串A转换为字符串B。这里所说的字符操作包括:
(1)删除一个字符;
(2)插入一个字符；
(3)将一个字符改为另一个字符。
将字符串A变换为字符串B所用的最少字符操作数称为字符串A到B的编辑距离,记为d(A,B)。试设计一个有效算法,对任给的2个字符串A和B,计算出它们的编辑距离d(A,B)。
要求：
输入：第1行是字符串A,第2行是字符串B。
输出：字符串A和B的编辑距离d(A,B)
思路：动态规划
开一个二维数组d[i][j]来记录a0-ai与b0-bj之间的编辑距离，要递推时，需要考虑对其中一个字符串的删除操作、插入操作和替换操作分别花费的开销，从中找出一个最小的开销即为所求
具体算法：
首先给定第一行和第一列，然后，每个值d[i,j]这样计算：d[i][j] = min(d[i-1][j]+1,d[i][j-1]+1,d[i-1][j-1]+(s1[i] == s2[j]?0:1));
最后一行，最后一列的那个值就是最小编辑距离
#include <stdio.h>
#include <string.h>
char s1[1000],s2[1000];
int min(int a,int b,int c) {
int t = a < b ? a : b;
return t < c ? t : c;
}
void editDistance(int len1,int len2)
{
int** d=new int*[len1+1];
for(int k=0;k<=len1;k++)
d[k]=new int[len2+1];
int i,j;
for(i = 0;i <= len1;i++)
d[i][0] = i;
for(j = 0;j <= len2;j++)
d[0][j] = j;
for(i = 1;i <= len1;i++)
for(j = 1;j <= len2;j++)
{
int cost = s1[i] == s2[j] ? 0 : 1;
int deletion = d[i-1][j] + 1;
int insertion = d[i][j-1] + 1;
int substitution = d[i-1][j-1] + cost;
d[i][j] = min(deletion,insertion,substitution);
}
printf("%d\n",d[len1][len2]);
for(int k=0;i<=len1;k++)
delete[] d[k];
delete[] d;
}
int main()
{
while(scanf("%s %s",s1,s2) != EOF)
editDistance(strlen(s1),strlen(s2));
}