区间dp合集

最新推荐文章于 2019-09-19 19:11:00 发布

Elliott__

最新推荐文章于 2019-09-19 19:11:00 发布

阅读量294

点赞数

分类专栏：动态规划

本文链接：https://blog.csdn.net/monochrome00/article/details/82458948

版权

动态规划专栏收录该内容

36 篇文章 0 订阅

订阅专栏

POJ - 2955 - Brackets

题目链接<http://poj.org/problem?id=2955>

题意：

给出一个含有中小括号的字符串，问你有多少个子序列是合法的。

题解：

注意是题目要求是子序列，所以区间dp好做。

如果 $(s[i]=='('&&s[j]==')')||(s[i]=='['&&s[j]==']')$ ，那么转移方程可以为 $dp[i][j]=dp[i+1][j-1]+2$

然后再 $dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+1][j])$ 转移出一个最小值即可。

#include<iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
using namespace std;
const int N=1e3+7;
char s[N];
int dp[N][N],inf=1<<20;
int main()
{
    int t;
    while(scanf("%s",s+1)!=EOF){
        if(strcmp(s+1,"end")==0) break;
        memset(dp,0,sizeof(dp));
        int n=strlen(s+1);
        for(int len=1;len<=n;len++){
            for(int i=1;i<=n-len+1;i++){
                int j=i+len-1;
                if((s[i]=='('&&s[j]==')')||(s[i]=='['&&s[j]==']'))
                    dp[i][j]=dp[i+1][j-1]+2;
                for(int k=i;k<j;k++)
                    dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+1][j]);
            }
        }
        printf("%d\n",dp[1][n]);
    }
    return 0;
}

LightOJ - 1422 - Halloween Costumes

题目链接<https://cn.vjudge.net/problem/LightOJ-1422>

题意：

一共有n天，每天都有对应的衣服要穿。可以穿一件衣服套在原来的衣服上，也可以脱去衣服。问最少要穿几次衣服。

题解：

数组 $dp[i][j]$ 表示第i天开始到第j天要穿几件衣服。

对于第j天，如果直接套一件衣服，那么转移方程为:

$dp[i][j]=dp[i][j-1]+1$

如果第j天不穿，也就是在第i~j-1天内存在 $a[k]==a[j]$ ，使得 $dp[i][j]$ 可以从第k天转移。那么第k+1~j-1天穿上的衣服都必须要脱掉，且这几天的衣服不能从第k天以前转移得出（不然第k天的衣服就会被脱去）。

所以可以列出转移方程：

$dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j-1])$

#include<iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
using namespace std;
const int inf=1e9+7;
int a[105],dp[105][105];
int main(){
    int t,n,cs=0;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        for(int len=1;len<=n;len++){
            for(int i=1;i+len-1<=n;i++){
                int j=i+len-1;
                dp[i][j]=dp[i][j-1]+1;
                for(int k=i;k<j;k++){
                    if(a[k]==a[j])
                        dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j-1]);
                }
            }
        }
        printf("Case %d: %d\n",++cs,dp[1][n]);
    }
}

HDU - 2476 - String painter

题目链接<http://acm.hdu.edu.cn/showproblem.php?pid=2476>

题意：

给出一个字符串a，变成字符串b。每次转换可以将一个子串变成同一个字符，问最少的转换次数。

题解：

开两个数组dp和ans。

dp代表假设字符串a为空串，即与字符串b没有一个相同字符情况下的答案；

ans为最终答案。

为什么要开两个？因为这题存在两个转移的关键点，且两者会产生冲突。

1）对于zzzzzzz转化为abcdefe，新来的e直接和上一个e一起转换：

if(b[k]==b[j]) dp[i][j]=min(dp[i][j],dp[i][k-1]+dp[k][j-1]);

2）对于字符串zzfzz转化为defgh，等于左右两边分别转换：

if(a[k]==b[k]) ans[i][j]=min(ans[i][j],ans[i][k-1]+ans[k+1][j]);

两者之间的冲突表现为zzfzz转化为eefee的情况：如果对整个字符串进行操作，使得zzfzz变成了eeeee，那么就无法进行第二项转换。因为原本相同的f已经被改变了。所以两个转换必须分两个数组来操作，最后取个最小值就行了。

#include<iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
using namespace std;
const int N=1e2+7;
char a[N],b[N];
int dp[N][N],ans[N][N];
int main()
{
    while(scanf("%s%s",a+1,b+1)!=EOF){
        int n=strlen(a+1);
        for(int len=1;len<=n;len++){
            for(int i=1;i+len-1<=n;i++){
                int j=i+len-1;
                ans[i][j]=dp[i][j]=dp[i][j-1]+1;
                for(int k=i;k<=j;k++){
                    if(b[k]==b[j]&&k!=j)
                        dp[i][j]=min(dp[i][j],dp[i][k-1]+dp[k][j-1]);
                    if(a[k]==b[k]) 
                        ans[i][j]=min(ans[i][j],ans[i][k-1]+ans[k+1][j]);
                }
                ans[i][j]=min(ans[i][j],dp[i][j]);
            }
        }
        printf("%d\n",ans[1][n]);
    }
    return 0;
}

HDU - 4283 - You Are the One

题目链接<http://acm.hdu.edu.cn/showproblem.php?pid=4283>

题意：

有n个男生，每个人都有一个屌丝值a[i]。他们轮流上去相亲，他们上台后的屌丝值为（k-1）*a[i]（k为他第k个上场）。每个男孩上场前需要进一个栈类型的黑箱，借此能够改变初始的出场顺序。问最后的屌丝值之和最低是多少？

题解：

因为每个男生必须入栈，所以可以利用栈的特性。

对于区间[i，j]。先把第i个人放进栈内，对于后面的人可以分为两组：

1）先于第i个人出场的（i+1~k）

2）后于第i个人出场的（k+1~j）

预处理一下前缀和就可以转移了。

还有样例的输入有问题。

#include<iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
using namespace std;
const int N=1e2+7;
const int inf=1e9+7;
int a[105],sum[105],dp[105][105];
int main()
{
    int t,n,cs=0;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            sum[i]=sum[i-1]+a[i];
        }
        for(int len=2;len<=n;len++){
            for(int i=1;i+len-1<=n;i++){
                int j=i+len-1;
                dp[i][j]=inf;
                for(int k=i;k<=j;k++){
                    int tmp=dp[i+1][k]+dp[k+1][j]+(sum[j]-sum[k])*(k-i+1)+a[i]*(k-i);
                    dp[i][j]=min(dp[i][j],tmp);
                }
            }
        }
        printf("Case #%d: %d\n",++cs,dp[1][n]);
    }
    return 0;
}
/*
2
5
1 2 3 4 5
5
5 4 3 2 2
*/

Elliott__

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
区间dp合集

POJ - 2955 - Brackets题目链接&lt;http://poj.org/problem?id=2955&gt;题意：给出一个含有中小括号的字符串，问你有多少个子序列是合法的。题解：注意是题目要求是子序列，所以区间dp好做。如果，那么转移方程可以为然后再转移出一个最小值即可。#include&lt;iostream&gt;#include&lt;c...
复制链接

扫一扫