第七次总结

区间DP
这一周学了区间DP，区间DP主要是把一个大区间拆分成几个小区间，先求小区间的最优值，然后合并起来求大区间的最优值。
大多数区间DP都可以用：

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++)
    {
        //DP方程的实现
    }
}

下面写了这一周学的几个题目及解答
例一：

石子合并一条直线上有N堆石子，现在要将所有石子合并成一堆，每次只能合并相邻的两堆，合并花费为新合成的一堆石子的数量，求最小的花费。
1堆，花费为0
2堆，花费为sum[2]
3堆，花费为min(a[1] + a[2], a[2] + a[3]) + sum[3]
如果我们有n堆，合并的最后一次操作一定是从两堆合并成一堆.

我们如果规定dp[i][j]为合并第i堆到第j堆的最小花费 ，则DP方程可写为： dp[i][j] = min(dp[i][k] + dp[k+1][j]) + sum[j] - sum[i-1] (i <= k < j)

代码如下：

#include <iostream>
#include<cstring>

using namespace std;
const int MAX=2000;
int dp[MAX][MAX],sum[MAX];
int main()
{
    int n;
    cin>>n;

    memset(dp,0x3f,sizeof(dp));
    for(int i=1;i<=n;i++)
        cin>>dp[i][i];
    for(int i=1;i<=n;i++)
    sum[i]=0;
    for(int i=1;i<n;i++)
    for(int j=1;j<=i;j++)
        sum[i]+=dp[j][j];
    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];
            }
        }
    }
    printf("%d\n",dp[1][n]);

}

例二：

n个字符组成长度为m的字符串，给出增删字符的花费，可在字符串任意位置增删字符，求把字符串修改成回文串的最小花费。

规定dp[i][j]为将[i,j]区间改成回文串的最小花费，可以看成有回文串
[i+1,j]在前面加一个字符 =>前面删或后面增
[i,j-1]在后面加一个字符 =>前面增或后面删
共四种情况，当a[i] == a[j]时，加个dp[i+1][j-1]的情况就好了

#include <iostream>
#include<cstring>

using namespace std;
const int MAXN = 2005;
char a[MAXN], ch;
int dp[MAXN][MAXN];
int add[30],sub[30];
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    scanf("%s", a+1);
    for (int i = 1; i <= n; i++)
    {
        scanf(" %c", &ch);
        scanf("%d %d", &add[ch-'a'], &sub[ch-'a']);
    }
    memset(dp, 0x3f, sizeof(dp));
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]);
            }
}
    printf("%d\n", dp[1][m]);
    return 0;
}

例三：

给出一个数n,要求在n的数位间插入(m-1)个乘号，将n分成了m段，求这m段的最大乘积。用dp[i][j]表示从第一位到第i位共插入j个乘号后乘积的最大值。根据区间DP的思想我们可以从插入较少乘号的结果算出插入较多乘号的结果。

这是一个整数划分问题，当我们要放第j的乘号时枚举放的位置时，状态转移方程为dp[i][j]=max(dp[i][j],dp[k][j-1]*num[k+1][i]),其中num[i][j]表示从s[i]到s[j]这段连续区间代表的数值。

代码如下：

#include <iostream>
#include<cstring>

using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)

typedef long long ll;
const int maxn = 25;
const ll mod = 1e9+7;
const ll INF = 1e18;
const double eps = 1e-9;

int m;
char s[maxn];
ll dp[maxn][maxn];
ll num[maxn][maxn];
int main()
{
    rush()
    {
        scanf("%s%d",s+1,&m);
        mst(dp,0);
        int len=strlen(s+1);
        for(int i=1;i<=len;i++)
        {
            num[i][i]=s[i]-'0';
            for(int j=i+1;j<=len;j++)
            {
                num[i][j]=num[i][j-1]*10+s[j]-'0';
            }
        }
         for(int i=1;i<=len;i++)
        {
            dp[i][0]=num[1][i];
        }
        for(int j=1;j<m;j++)
        for(int i=j+1;i<=len;i++)
        for(int k=j;k<i;k++)
        {
            dp[i][j]=max(dp[i][j],dp[k][j-1]*num[k+1][i]);
        }
        printf("%lld\n",dp[len][m-1]);
    }
    return 0;
}

以上这三个题只是我们这周学的其中一部分，但是这周我们学的题中我对于第二种模型还是没搞清楚，我会在接下来的时间里再去看看思路，搞明白后再来补上。