区间dp 题目小结

区间dp 题目小结

区间DP是一类在区间上进行动态规划的最优问题，一般是根据问题设出一个表示状态的dp，可以是二维的也可以是三维的，一般情况下为二维。然后将问题划分成两个子问题，也就是一段区间分成左右两个区间，然后将左右两个区间合并到整个区间，或者说局部最优解合并为全局最优解，然后得解。
一般可以枚举左右边界 或者 枚举一个边界和区间的长度来做，看题目的情况，如果需要一段一段来算，每段长度一样那就后者，否则就前者。

第一题 Light oj 1422 Halloween Costumes
题目
题意：告诉有n场晚会中需要穿的衣服，衣服是可以套在其他衣服外面的，告诉了序列顺序之后求出最少需要穿多少次衣服。
先枚举左右边界，然后找到区间之内和现在穿的一样的衣服，如果有一样的那现在这件衣服可以二次利用，但是这件衣服左右就分隔开来了，现在的状态就是左边段加上右边段的和
可得转移方程 dp[i][j]=min(dp[i][j],dp[i+1][k-1]+dp[k][j]);

#include<iostream>
#include<algorithm>
#include<stdio.h>
using namespace std;
int a[300];
int dp[300][300];
int main(){
    int t;
    cin>>t;
    int cas=0;
    while(t--){
        int n;
        cin>>n;
        for(int i=1;i<=n;i++){
            cin>>a[i];
        }
        for(int i=1;i<=n;i++){
            for(int j=i;j<=n;j++){
                dp[i][j]=j-i+1;
            }
        }
        for(int i=n;i>=1;i--){
            for(int j=i+1;j<=n;j++){
                if(a[i]!=a[i+1])dp[i][j]=dp[i+1][j]+1;
                for(int k=i+1;k<=j;k++){
                    if(a[k]==a[i])dp[i][j]=min(dp[i][j],dp[i+1][k-1]+dp[k][j]);
                }
            }
        }
        printf("Case %d: %d\n",++cas,dp[1][n]);
    }
    return 0;
}

第二题 poj 2955 Brackets
题目
括号匹配
枚举左右边界，如果左右相同那就加二，还有终情况是左右分开来类似()()，就是将这个区间分开来，左边的数量加上右边的数量 dp[l][r]=max(dp[l][r],dp[l][k]+dp[k][r]);

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int dp[110][110];
int main(){
    string s;
    while(1){
        cin>>s;
        if(s=="end")break;
        int n=s.length();
        memset(dp, 0, sizeof(dp));
        for(int l=n-2;l>=0;l--){
            for(int r=l+1;r<n;r++){
                if((s[l]=='('&&s[r]==')')||(s[l]=='['&&s[r]==']'))dp[l][r]=dp[l+1][r-1]+2;
                for(int k=l+1;k<r;k++){
                    dp[l][r]=max(dp[l][r],dp[l][k]+dp[k][r]);
                }
            }
        }
        cout<<dp[0][n-1]<<endl;
    }
    return 0;
}

第三题 CF 149 D Coloring Brackets
题目
也是括号匹配，但有了其他要求，要求每一对括号，一个上颜色，一个不上颜色，相邻的两个括号颜色不能相同，但可以都没有上颜色。题目保证整个序列一定合理。
dp[710][710][3][3];
这么设dp，后面两个3表示左边和右边的颜色
if(l+1==r)dp[l][r][0][1]=dp[l][r][0][2]=dp[l][r][1][0]=dp[l][r][2][0]=1; 确定一个初始状态，如果只有两个，那就一定是1
先判断左右是不是一对括号，是的话直接转移，一个从四个状态转移过来，但有一个颜色不符合要求，如果不是一对的话，直接写出左边界到他对应的半个括号间的可能性 乘 右边界对应的半个括号的可能性，就是左右独立开来了一个区间分成两个。如果对应的超出了现在的范围，dp会是0，所以不会计入当前的数量

#include<bits\stdc++.h>
using namespace std;
#define ll long long
int b[710];
ll dp[710][710][3][3];
const int mod=1000000007;
int main(){
    string s;
    cin>>s;
    int len=s.length();
    stack<int>st;
    for(int i=0;i<len;i++){
        if(s[i]=='(')st.push(i);
        else {
            b[i]=st.top();
            b[st.top()]=i;
            st.pop();
        }
    }
    for(int l=len-2;l>=0;l--){
        for(int r=l+1;r<len;r++){
            if(l+1==r)dp[l][r][0][1]=dp[l][r][0][2]=dp[l][r][1][0]=dp[l][r][2][0]=1;
            if(b[l]==r){
                for(int i=0;i<3;i++){
                    for(int j=0;j<3;j++){
		                if(i!=2) dp[l][r][2][0]=(dp[l][r][2][0]+dp[l+1][r-1][i][j])%mod;
                        if(i!=1) dp[l][r][1][0]=(dp[l][r][1][0]+dp[l+1][r-1][i][j])%mod;
                        if(j!=2) dp[l][r][0][2]=(dp[l][r][0][2]+dp[l+1][r-1][i][j])%mod;
                        if(j!=1) dp[l][r][0][1]=(dp[l][r][0][1]+dp[l+1][r-1][i][j])%mod;
                    }
                }
            }
            else{
                for(int i=0;i<3;i++){
                    for(int j=0;j<3;j++){
                        for(int p=0;p<3;p++){
                            for(int q=0;q<3;q++){
                                if(j==p&&j!=0)continue;
                                dp[l][r][i][q]=(dp[l][r][i][q]+(dp[l][b[l]][i][j]*dp[b[l]+1][r][p][q])%mod)%mod;                            
                            }
                        }
                    }
                }
            }
        }
    }
    ll ans=0;
    for(int i=0;i<3;i++){
        for(int j=0;j<3;j++){
            ans+=dp[0][len-1][i][j];
            ans=ans%mod;
        }
    }
    cout<<ans;

}

第三题 1651 Multiplication Puzzle
题目
正面求删除很难，从后往前想，想插入。然后每次插入一个点，插入某个点后，想要变回原来的段，还需要插入左边和右边剩下的内容，再单独思考插旁边两段。所以转移方程就是左右两边的dp值加上这个点k和左右端点的乘积。
dp[l][r] = min(dp[l][r], dp[l][k - 1] + dp[k + 1][r] + a[l - 1] * a[k] * a[r + 1]);
因为需要

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
#define ll long long
ll dp[330][330];
ll a[330];
const ll INF = 1e18;
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];   
    }

    for (int i = 2; i < n; i++) {
        dp[i][i] = a[i] * a[i - 1] * a[i + 1];
    }
    for (int len = 1; len <= n - 2; len++) {
        for (int l = 2; l < n-1; l++) {
            int r=l+len;
            dp[l][r] = INF;
            for (int k = l; k <= r; k++) {
                dp[l][r] = min(dp[l][r], dp[l][k - 1] + dp[k + 1][r] + a[l - 1] * a[k] * a[r + 1]);
            }
        }
    }
    cout << dp[2][n - 1];
    return 0;
}

第四题 Zoj 3469 Food Delivery
题目

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
#define ll long long
const int inf = 0x3f3f3f3f;
struct node{
    int x,b;    
    bool operator <(const node& b)const{
        return x<b.x;
    }
}a[1010];
const int maxn=1000+10;
int dp[maxn][maxn][2];
int sum[maxn];
int get_cost(int l,int r)
{
    if(l > r)return 0;
    return sum[r] - sum[l-1];
}
int main(){
    int n,v,x;
    while(cin>>n>>v>>x){
        memset(dp,inf,sizeof(dp));
        for(int i=1;i<=n;i++){
            cin>>a[i].x>>a[i].b;
        }
        a[n+1].x=x;
        a[n+1].b=0;
        sort(a+1,a+2+n);
        int pos;
        for(int i=1;i<=n+1;i++){
            if(a[i].x==x&&a[i].b==0)pos=i;
            sum[i] = sum[i-1] + a[i].b;
        }
        dp[pos][pos][0]=dp[pos][pos][1]=0;
        for(int l=pos;l>=1;l--){
            for(int r=pos;r<=n+1;r++){
                int cost=get_cost(1,l-1)+get_cost(r+1,n+1);
                dp[l][r][0]=  min(dp[l][r][0],dp[l+1][r][0] + (a[l+1].x-a[l].x)*(a[l].b+cost));
                dp[l][r][0] = min(dp[l][r][0],dp[l+1][r][1] + (a[r].x-a[l].x)*(a[l].b+cost));
                dp[l][r][1] = min(dp[l][r][1],dp[l][r-1][0] + (a[r].x-a[l].x)*(a[r].b+cost));
                dp[l][r][1] = min(dp[l][r][1],dp[l][r-1][1] + (a[r].x-a[r-1].x)*(a[r].b+cost));
            }
        }
        cout<<min(dp[1][n+1][0],dp[1][n+1][1])*v<<endl;
    }
}