学习总结：区间dp

这几天在做有关区间dp的题，在学习中，现在先总结一下，之后就只能靠刷题了。

概念

这里先复述一下区间dp的概念：
同样是求最优解的问题，区间dp就是在区间上进行动态规划，我们可以把大区间转化成小区间来处理，然后合并小区间的 最优解进而得出整个大区间上最优解。主要的方法有两种，记忆化搜索和递推。

一般区间DP实现代码

区间dp的格式一般相差不大：
memset(dp, 0x3f, sizeof(dp));
for (int i = 1; i <= n; i++） //区间长度为1的初始化
dp[i][i] = 0;
for (int len = 2; len <= n; len++) //枚举区间长度
{
for (int i = 1, j = len; j <= n; i++, j++) //区间[i,j]
{
//DP方程实现
}
}

三种模型

1.第一种模型：将区间从任意一个位置分成两个子区间，如：dp[i][k]、dp[k+1][j]；从i到j区间中找到一个k使之分为两个区间，一个是区间由i到k，另外一个为k+1到j。
例题：石子合并问题：
一条直线上有N堆石子，现在要将所有石子合并成一堆，每次只能合并相邻的两堆，合并花费为新合成的一堆石子的数量，求最小的花费。

memset(dp, 0x3f, sizeof(dp));
for (int i = 1; i <= n; i++) 
    dp[i][i] = 0;
for (int len = 2; len <= n; len++)
{
    for (int i = 1, j = len; j <= n; i++, j++)
    {
        for (int k = i; k < j; k++)
        {
            if(dp[i][j] > dp[i][k] + dp[k+1][j] + sum[j] - sum[i-1])
                dp[i][j] = dp[i][k] + dp[k+1][j] + sum[j] - sum[i-1];
        }
    }

2.第二种模型：
将区间划分为[i+1,k-1]和[k+1][j]这两个区间，相当于模型一中将区间中的i项和找到的k项提了出来，所划的区间。
例题：括号匹配
给一个括号组成的字符串，问最多能匹配多少个括号

memset(dp, 0, sizeof(dp));
    int n = strlen(a+1);
    for (int len = 2; len <= n; len++)
    {
        for(int i = 1, j = len; j <= n; i++, j++)
        {
            dp[i][j] = dp[i+1][j];
            for (int k = i; 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+1][j] + 2);
        }

3.第三种模型
这种类型只和左右边界相关，不用再区间i到j中寻找一个k将它分为两个区间，而是直接再区间i到j的首尾进行操作。
例题：
n个字符组成长度为m的字符串，给出增删字符的花费，可在字符串任意位置增删字符，求把字符串修改成回文串的最小花费。
规定dp[i][j]为将[i,j]区间改成回文串的最小花费，可以看成有回文串

for (int i = 1; i <= m; i++) 
        dp[i][i] = 0;
    for (int len = 2; len <= m; len++)
        for(int i = 1, j = len; j <= m; i++, j++)
        {
            dp[i][j] = min(dp[i][j], min(add[a[i]-'a'],sub[a[i]-'a']) + dp[i+1][j]);
            dp[i][j] = min(dp[i][j], dp[i][j-1] + min(add[a[j]-'a'],sub[a[j]-'a']));
            if (a[i] == a[j])
            {
                if (len==2) 
                    dp[i][j] = 0;
                else
                    dp[i][j] = min(dp[i][j], dp[i+1][j-1]);
            }