【DP练习】区间DP

1、LightOJ 1422 Halloween Costumes

题目链接：http://lightoj.com/volume_showproblem.php?problem=1422

题意：gappu要参加n场万圣节晚会，每场他都要cosplay，所穿的衣服可以叠加穿在身上，但是一旦脱掉就不会再穿，给出每场晚会要穿的衣服编号，后面的场次服装可以与前面的相同，问你他最少需要消耗多少件衣服。

思路：dp[i][j]表示从第i场到第j场晚会最少穿多少件衣服，如果[i+1, j]都没有服装与第i场的一样，那么dp[i][j] = dp[i+1][j] + 1. 如果[i+1, j]中的第k场的服装与当前i的相同，则dp[i][j] = min(dp[i+1][k-1]+dp[k][j], dp[i][j]); 其中dp[i+1][k-1] 表示第i场的服装一直穿着遇到第k件的时候脱掉所有[i+1, k-1]件。每次枚举k便可。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int dp[1000][1000];
int a[300];
int main()
{
    int T;
    scanf("%d", &T);
    for(int cas = 1; cas <= T; cas ++) {
        int n;
        scanf("%d", &n);
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= n; i ++) scanf("%d", &a[i]);
        for(int i = 1; i <= n; i ++) dp[i][i] = 1;


        for(int i = n-1; i > 0; 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+1][k-1]+dp[k][j], dp[i][j]);
            }
        }
        cout <<"Case "<<cas<<": "<< dp[1][n] << endl;
    }
}

 2、POJ 2955 Brackets

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

题意：求括号的最大匹配数。

思路：dp[i][j] 表示从i到j最大的匹配数，每次循环开始预设所有的括号都不匹配，则dp[i][j] = dp[i+1][j]; 在[i+1, j] 枚举k，当char[k] == char[i]时，dp[i][j] = max(dp[i][j], dp[i+1][k-1]+dp[k][j] + 2).

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
using namespace std;
int main()
{
    char arr[200];
    while(1){
        scanf("%s", arr);
        if(arr[0] == 'e') break;
        int len = strlen(arr);
        int dp[200][200] = {0};
        for(int i = len-1; i >= 0; i--) {
            for(int j = i+1; j < len; j++) {
                dp[i][j] = dp[i+1][j];
                char x = arr[i];
                for(int k = i+1; k <= j; k++) {
                    if((x == '(' && arr[k] == ')') || (x == '[' && arr[k] == ']')){
                        dp[i][j] = max(dp[i][j], dp[i+1][k-1]+dp[k][j] + 2);
                    }
                }
            }
        }
        printf("%d
", dp[0][len-1]);

    }
    return 0;
}

3、POJ 1141Brackets Sequence（路径还原）

题意：括号的最少补全。输出补全后序列。

思路：DP路径还原 。rel[i][j]表示[i, j]中与arr[i]补全的位置，初始化为-1。dp[i][j] 表示[i, j]中最小的补全数，最初假设arr[i]不匹配，则dp[i][j]=dp[i+1][j]+1;然后每次枚举i < k <= j, 当arr[i]与arr[k]匹配dp[i][j] =min( dp[i+1][k-1]+dp[k][j]-1, dp[i][j]), rel记录转移;最后递归恢复路径。（因为答案不止一个，非递归恢复写得比较脑残然后WA了好几发）

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;
int dp[300][300], rel[300][300];
char arr[300];
bool vis[300];
void mark(int i, int j)
{
    if(i >= j) return ;
    if(rel[i][j] == -1) mark(i+1, j);
    else {
        vis[i] = vis[rel[i][j]] = 1;
        mark(i+1, rel[i][j]-1);
        mark(rel[i][j], j);
    }
}
int main()
{
    while(gets(arr) > 0){
        memset(dp, 0, sizeof(dp));
        memset(rel, -1, sizeof(rel));
        memset(vis, 0, sizeof(vis));

        int len = strlen(arr);
        for(int i  = 0; i < len; i++) dp[i][i] = 1;
        for(int i = len-1; i >= 0; i--) {
            for(int j = i+1; j < len; j++) {
                dp[i][j] = dp[i+1][j] + 1;
                rel[i][j] = -1;
                for(int k = i+1; k <= j; k++) {
                    if((arr[i] == '(' && arr[k] == ')') || (arr[i] == '[' && arr[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;
                            rel[i][j] = k;
                        }
                    }
                }
            }
        }
        mark(0, len-1);
        for(int i = 0; i < len; i++) {
            if(vis[i]) printf("%c", arr[i]) ;
            else {
                if(arr[i] == '(' || arr[i] == ')') printf("()");
                else printf("[]");
            }
        }printf("
");
    }
    return 0;
}

4、POJ3280 Cheapest Palindrome

题意：给你一个字符串，通过删除字符和增加字符构造成回文串，删除和增加都有相应的代价。问构造回文串的最小代价。

思路：dp[i][j] 代表[i, j]是回文串时的最小代价。则有三种转移情况：1）假设[i+1, j]是回文，增/删s[i]的代价，dp[i][j] = min(dp[i+1][j]+add_cost[i], dp[i+1][j]+del_cost[i]);2）dp[i][j] = min(dp[i][j-1]+add_cost[j], dp[i][j-1]+del_cost[j]);3）当s[i] == s[j]时， dp[i][j] = min(dp[i][j], d[i+1][j-1]);

(一直不知道自己WA的7、8次到底是为什么，重写了一遍就过了Orz)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
using namespace std;
int dp[2005][2005];
char s[2005];
int add[30], del[30];
int main()
{
    int n, m;
    while(scanf("%d%d", &n, &m) != EOF) {
        scanf("%s", s);
        for(int i = 0; i < n; i ++) {
            getchar();
            char c; cin >> c;
            scanf("%d%d", &add[c-'a'], &del[c-'a']);
        }
        memset(dp, 0, sizeof(dp));
        for(int i = m-2; i >= 0; i--){
            for(int j = i+1; j < m; j++) {
                dp[i][j] = min(dp[i+1][j]+add[s[i]-'a'], dp[i+1][j]+del[s[i]-'a']);
                int b = min(dp[i][j-1]+add[s[j]-'a'], dp[i][j-1]+del[s[j]-'a']);
                dp[i][j] = min(b, dp[i][j]);
                if(s[i] == s[j]) dp[i][j] = min(dp[i][j], dp[i+1][j-1]);
            }
        }
        cout << dp[0][m-1] << endl;
    }
}