区间dp

区间动态规划是从区间的角度来考虑问题的。对于每段区间，它的最优值是由几段更小的区间的最优值得到，这算是分治思想的一种应用吧。

就拿http://acm.fafu.edu.cn/problem.php?id=1502
合并石子这一题来说。要求得区间1-->n石子合并的最小花费
设dp[1][n] 为合并区间1--->n的最小花费。
区间的最后一次合并一定是1--->k 与 k+1-->n合并
所以合并区间1--->k的花费最小,和合并区间k+1--->n的花费最小，才能使得合并区间1--->n的花费最小。
所以状态转移方程为：dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]);               sum[i]表示前i堆石子的总个数。
方程的思想是在区间的角度上来思考问题的，一个大区间的问题转化为两个小区间的问题

#include <stdio.h>
const int INF = 1 << 30;
const int N = 100 + 10;
int dp[N][N],sum[N];
int min(const int &a, const int &b)
{
    return a < b ? a : b;
}
int main()
{
    int n,i,j,k,z;
    scanf("%d",&n);
    for(i=1; i<=n; ++i)
        for(j=1; j<=n; ++j)
            dp[i][j] = INF;
    for(i=1; i<=n; ++i)
    {
        scanf("%d",&sum[i]);
        sum[i] += sum[i-1];
        dp[i][i] = 0;
    }
    for(z=2; z<=n; ++z)//枚举区间的长度
        for(i=1; i<=n-z+1; ++i)//枚举区间的起点
        {
            j = i + z - 1;
            for(k=i; k<j; ++k)//枚举区间的断点，将区间分为两个更小的区间。
                dp[i][j] = min(dp[i][j], dp[i][k]+dp[k+1][j]+sum[j] - sum[i-1]);
        }
    printf("%d\n",dp[1][n]);
}

 

poj2995 Brackets  http://poj.org/problem?id=2955

给出一个括号字符串，求出一个子序列（和子串是不一样的）使得括号的匹配个数最大
区间dp，从区间的角度来思考，这题的关键应该是怎么把一个区间分为两个区间。
dp[i][j]表示区间i--->j的最大匹配个数
有两种情况
如果 for(k=i+1; k<=j; ++k) if(str[i] =='[' && ']'== str[k] || str[i]=='(' && str[k]==')')
那么dp[i][j] = max(dp[i][j], dp[i+1][k-1]+dp[k+1][j]+2) //下标可能越界，数组要开大点
匹配的括号 i AAA k BBB 将区间分为了更小的两个区间.
另一种情况是：没有一个k 使得 str[i] =='[' && ']'== str[k] || str[i]=='(' && str[k]==')'
那么dp[i][j] = dp[i+1][j] 即子序列的下标不可能从i开始，而要从i+1开始。

#include <stdio.h>
#include <string.h>
const int N = 100 + 10;
char str[N];
int dp[N][N];
int max(const int &a, const int &b)
{
    return a > b ? a : b;
}
int main()
{
    //freopen("in.txt","r",stdin);
    int i,j,k,z;
    while(true)
    {
        gets(str+1);
        if(str[1] == 'e')
            break;
        int n = strlen(str+1);
        memset(dp, 0, sizeof(dp));
        for(z=2; z<=n; ++z)
            for(i=1; i<=n-z+1; ++i)
            {
                j = i + z - 1;
                dp[i][j] = dp[i+1][j];
                for(k=i+1; k<=j; ++k)
                if(str[i] =='[' && ']'== str[k] || str[i]=='(' && str[k]==')')
                    dp[i][j] = max(dp[i][j], dp[i+1][k-1]+dp[k+1][j]+2);
                //else
                    //dp[i][j] = dp[i+1][j];   不能放在这里，因为肯定会出现不匹配的情况，这就会把之前的值给覆盖掉

            }
        printf("%d\n",dp[1][n]);
    }
    return 0;
}

 

poj3280 Cheapest Palindrome  http://poj.org/problem?id=3280

dp[i][j] 表示将区间i--->j的字符串变为回文串的最小花费
if(str[i] == str[j])
dp[i][j] = dp[i+1][j-1];
else
dp[i][j] = min(dp[i+1][j] + 在j后面增加str[i]的花费, dp[i+1][j]+删除str[i]的花费 ,dp[i][j-1]+在i前面增加str[j]的花费, dp[i][j-1]+删除str[j]的花费);

#include <stdio.h>
#include <string.h>
const int N = 2000 + 10;
char str[N];
struct node
{
    int add,del;
}cost[26];
int min( int a,  int b,  int c,  int d)
{
    if(a > b)
        a = b;
    if(a > c)
        a = c;
    if(a > d)
        a = d;
    return a;
}
int dp[N][N];
int main()
{
    freopen("in.txt","r",stdin);
    int n,m,i,j,z,k;
    char ch[2];
    scanf("%d%d%s",&n,&m,str+1);
    for(i=0; i<n; ++i)
    {
        scanf("%s",ch);
        scanf("%d%d",&cost[ch[0]-'a'].add,&cost[ch[0]-'a'].del);
    }
    
    for(z=2; z<=m; ++z)
        for(i=1; i<=m-z+1; ++i)
        {
            j = i + z - 1;
            if(str[i]==str[j])
                dp[i][j] = dp[i+1][j-1];
            else
                dp[i][j] = min(dp[i+1][j] + cost[str[i]-'a'].add, dp[i+1][j] + cost[str[i]-'a'].del,
                                dp[i][j-1] + cost[str[j]-'a'].add, dp[i][j-1] + cost[str[j]-'a'].del);
        }
    printf("%d\n",dp[1][m]);
}

 

poj1141 Brackets Sequence  http://poj.org/problem?id=1141

dp[i][j] 表示将区间i--->j的括号变成regular sequence的最小花费.和上面的想法都差不多。

关键是记录路径。 path[i][j] == -1时，说明i+1--->j中没有任何括号和str[i]配对，所以你需要加入一个括号与str[i]配对，path[i][j] = k时，说明str[i] 与str[k]配对。

#include <stdio.h>
#include <string.h>
const int N = 100 + 10;
const int INF = 1 << 30;
int dp[N][N];
int path[N][N];
char str[N];
void print(int i, int j)
{
    if(i > j)
        return ;
    if(path[i][j] == -1)
    {
        if(str[i]=='(' || str[i]==')')
            printf("()");
        else
            printf("[]");
        print(i+1,j);
    }
    else
    {
        if(str[i]=='(' || str[i]==')')
            printf("(");
        else
            printf("[");
        print(i+1,path[i][j]-1);
        if(str[i]=='(' || str[i]==')')
            printf(")");
        else
            printf("]");
        print(path[i][j]+1,j);
    }
}
int main()
{
    int n,i,j,k,z;
    gets(str+1);
    memset(path,-1,sizeof(path));
    n = strlen(str+1);

    for(i=1; i<=n; ++i)
        dp[i][i] = 1;
    for(z=2; z<=n; z++)
        for(i=1; i<=n-z+1; ++i)
        {
            j = z + i - 1;
            dp[i][j] = dp[i+1][j] + 1;
            path[i][j] = -1;
            for(k=i+1; k<=j; ++k)
            {
                if(str[i]=='(' &&str[k]==')' || str[i]=='['&&str[k]==']')
                if(dp[i][j] > dp[i+1][k-1] + dp[k+1][j])
                {
                    dp[i][j] = dp[i+1][k-1] + dp[k+1][j];
                    path[i][j] = k;
                }
            }
        }
    print(1,n);
    puts("");
}