区间dp总结篇

前言:这两天没有写什么题目,把前两周做的有些意思的背包题和最长递增、公共子序列写了个总结。反过去写总结,总能让自己有一番收获......就区间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));   
}  

 

posted @ 2013-08-04 10:48  紫忆  阅读(...)  评论(...编辑  收藏