动态规划入门（九）区间DP

阿阿阿安

已于 2024-03-13 14:59:06 修改

阅读量5.6w

点赞数 213

分类专栏：【算法竞赛】 # 动态规划文章标签：动态规划算法

于 2018-05-03 18:07:49 首次发布

本文链接：https://blog.csdn.net/qq_40772692/article/details/80183248

版权

【算法竞赛】同时被 2 个专栏收录

186 篇文章 15 订阅

订阅专栏

动态规划

18 篇文章 3 订阅

订阅专栏

一. 区间dp概述

顾名思义，区间dp就是在区间上进行动态规划，求解一段区间上的最优解；该问题的求解思路主要是通过合并小区间的最优解进而得出整个大区间上最优解的dp算法。

二. 核心思路

既然让我求解在一个区间上的最优解，那么我把这个区间分割成一个个小区间，求解每个小区间的最优解，再合并小区间得到大区间即可。所以在代码实现上，我可以枚举区间长度len为每次分割成的小区间长度（由短到长不断合并），内层枚举该长度下可以的起点，自然终点也就明了了。然后在这个起点终点之间枚举分割点，求解这段小区间在某个分割点下的最优解。其板子如下：

for(int len = 1;len<=n;len++){//枚举长度
        for(int j = 1;j+len<=n+1;j++){//枚举起点，ends<=n
            int ends = j+len - 1;
            for(int i = j;i<ends;i++){//枚举分割点，更新小区间最优解
                dp[j][ends] = min(dp[j][ends],dp[j][i]+dp[i+1][ends]+something);
            }
        }
    }

三. 朴素区间dp（n^3)

1. 线性区间

1.1 引例描述

Problem Description

N 堆石子摆成一条线。现要将石子有次序地合并成一堆。规定每次只能选相邻的 2 堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的代价。计算将 N 堆石子合并成一堆的最小代价。

例如 1 2 3 4，代价最低合并方法为：

1 2 3 4 => 3 3 4(3) => 6 4(9) => 10(19)

1.2 题解代码

令dp[i][j]表示石子中第i堆到第j堆合并的最小代价，则 j~ends 堆合并 = 较小的（原来，分割点i坐部分重量 + 分割点i右边部分重量 + 合并后两堆总重量），该问题的转移方程可以总结如下：

dp[j][ends] = min(dp[j][ends],dp[j][i]+dp[i+1][ends]+weigth[i][ends]);

注意实现时可以用sum[j] - sum[i - 1]表示i~j堆的重量来进行优化。

#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f
int stone[105];
int dp[105][105];
int sum[105];
int main()
{
    int n;
    scanf("%d",&n);
    memset(sum,0,sizeof(sum));
    memset(dp,INF,sizeof(dp));
    for(int  i =1;i<=n;i++){
        scanf("%d",&stone[i]);
        sum[i] = sum[i - 1] + stone[i];//重量
        dp[i][i] = 0;
    }
    for(int len = 1;len<=n;len++){//枚举长度
        for(int j = 1;j+len<=n+1;j++){//枚举起点，ends<=n
            int ends = j+len - 1;
            for(int i = j;i<ends;i++){//枚举分割点
                dp[j][ends] = min(dp[j][ends],dp[j][i]+dp[i+1][ends]+sum[ends]-sum[j-1]);//更新状态
            }
        }
    }
    cout<<dp[1][n]<<endl;
    return 0;
}

2. 环状区间

2.1 引例描述

codevs 2102 环状石子归并

Problem Description

N 堆石子首尾相接摆成一个环。现要将石子有次序地合并成一堆。规定每次只能选相邻的 2 堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的代价。计算将 N 堆石子合并成一堆的最小代价。

2.2 题解代码

环状以后合并区间的情况就可以从后往前合并，最后合并完成可能是1~n,2~n~1,3~n~2.....这种n个石子合并的情况。所以我们可以破环成链，将前n-1各元素也放到n后面构成一个线性的环状序列，在对这个序列进行线性dp即可。

#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f
int stone[105];
int dpmin[205][205];//最小
int dpmax[205][205];//最大
int sum[205];
int main()
{
    int n;
    scanf("%d",&n);
    memset(sum,0,sizeof(sum));
    memset(dpmin,INF,sizeof(dpmin));
    memset(dpmax,-1,sizeof(dpmax));
    for(int  i =1;i<=n;i++){
        scanf("%d",&stone[i]);
        sum[i] = sum[i - 1] + stone[i];
        dpmin[i][i] = 0;
        dpmax[i][i] = 0;
    }
    for(int i = 1;i<=n;i++){
        sum[i+n] = sum[i+n-1]+stone[i];//展开的n后面的n-1~1重量
        dpmin[i+n][i+n] = 0;
        dpmax[i+n][i+n] = 0;
    }
    for(int len = 1;len<=n;len++){//长度还是最大n
        for(int j = 1;j+len<=2*n;j++){//起点枚举最大到2*n-1,ends<=2*n-1
            int ends = j+len - 1;
            for(int i = j;i<ends;i++){//注意！i<ends！！！因为i=ends时，dp[ends+1][ends]是不成立的！
                dpmin[j][ends] = min(dpmin[j][ends],dpmin[j][i]+dpmin[i+1][ends]+sum[ends]-sum[j-1]);
                dpmax[j][ends] = max(dpmax[j][ends],dpmax[j][i]+dpmax[i+1][ends]+sum[ends]-sum[j-1]);
            }
        }
    }
    int ansmin = 0xfffffff;
    int ansmax = -1;
    for(int i = 1;i<=n;i++){
        ansmin = min(ansmin,dpmin[i][i+n-1]);//找1~n,2~n~1,3~n~2....的合并n个堆的中最大和最小的值
        ansmax = max(ansmax,dpmax[i][i+n-1]);
    }
    cout<<ansmin<<endl;
    cout<<ansmax<<endl;
    return 0;
}

四. 时间优化（n^2)

在查找最优分割点的时候，我们浪费了大量时间。为了优化时间复杂度，我们可以把最优分割点保存下来，这样在查找的时候利用保存的最优分割点来优化查找过程。该思路主要通过四边形优化来实现。

1. 四边形不等式

四边形不等式主要用来寻找 s[i][j]（i~j的最优分割点）与其他分割点的关系。该不等式的内容是指：如果某计算项满足a<b<=c<d且f[a][c]+f[b][d]<=f[a][d]+f[b][c]，则说这个关系满足四边形不等式。简而言之，交叉小于包含。四边形不等式可以表示为 s[i][j-1]<=s[i][j]<=s[i+1][j] ，其证明过程如下：

（1）证明w满足四边形不等式，这里w是m的附属量，形如m[i,j]=opt{m[i,k]+m[k,j]+w[i,j]}，此时大多要先证明w满足条件才能进一步证明m满足条件

（2）证明m满足四边形不等式

（3）证明s[i,j-1]≤s[i,j]≤s[i+1,j]

（4）详细证明过程请参考四边形不等式优化

2. 环状区间优化

以石子归并v2为例。

#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f
int dp[2005][2005];
int sum[2005];
int relation[2005][2005];
int num[2005];
int main()
{
    int n;
    scanf("%d",&n);
    memset(sum,0,sizeof(sum));
    memset(dp,0x3f,sizeof(dp));
    for(int i = 1;i<=n;i++){
        scanf("%d",&num[i]);
        dp[i][i] = 0;
        relation[i][i] = i;
        sum[i] = sum[i-1] + num[i];
    }
    for(int i = 1;i<=n;i++){
        sum[i+n] = sum[i+n-1] +num[i];
        relation[i+n][i+n] = i+n;//分割点初始化
        dp[i+n][i+n] = 0;
    }
    for(int len = 1;len<=n;len++){
        for(int j = 1;j+len<=2*n;j++){
            int ends = j+len - 1;
            for(int k = relation[j][ends-1];k<=relation[j+1][ends];k++){//k的范围
                if(dp[j][ends]>dp[j][k]+dp[k+1][ends]+sum[ends]-sum[j-1])
                {
                    dp[j][ends]=dp[j][k]+dp[k+1][ends]+sum[ends]-sum[j-1];
                    relation[j][ends] = k;
                }
            }
        }
    }
    int ans = 0xfffffff;//一定要开0xfffffff不然错QAQ
    for(int i = 1;i<=n;i++){
        ans = min(ans,dp[i][i+n-1]);
    }
    printf("%d\n",ans);
    return 0;
}

五. 例题分析

1. Poj2955 括号匹配（一）

给出一个的只有'(',')','[',']'四种括号组成的字符串，求最多有多少个括号满足题目里所描述的完全匹配。

这里的状态转移是以一个if为基础的，如果s[i]与s[j]匹配，那么明显的dp[i][j] = dp[i+1][j-1]+2;然后在这个基础上枚举分割点k。我们令dp[i][j]表示第i~j个字符间的最大匹配字符数，由此可以得到状态转移方程如下：

$dp[i][j] = \left\{\begin{matrix} dp[i+1][j-1]+2,s[i] \equiv s[j]\\ max(dp[i][j],dp[i][k]+dp[k+1][j]),s[i] \not\equiv s[j] \end{matrix}\right.$

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int dp[105][105];
int main()
{
    char s[105];
    while(scanf("%s",s+1)!=EOF)
    {
        memset(dp,0,sizeof(dp));//dp初始化为0，因为一方面是找最大之，一方面初始匹配数为0
        int len = strlen(s+1);//dp[i][i]不用处理，因为自己和自己不匹配就是0
        if(s[1]=='e')break;
        for(int l = 1;l<=len;l++){
            for(int i = 1;i+l<=len+1;i++){
                int j= i+l-1;
                if((s[i]=='('&&s[j]==')')||(s[i]=='['&&s[j]==']')){//如果匹配，先更新
                    dp[i][j] = dp[i+1][j-1]+2;
                }
                for(int k = i;k<j;k++){//k<j
                    dp[i][j] = max(dp[i][j],dp[i][k]+dp[k+1][j]);
                }
            }
        }
        cout<<dp[1][len]<<endl;
    }
    return 0;
}

2. Poj1651 抽卡片

给你n个数字，要求不能删除两端点的数字，然后删除其他数字的代价是该数字和左右相邻数字的乘积，问把数字（除端点）删完后的最小总代价。

因为最后都要删掉中间所有的数字，所以我们可以分隔一个个小区间删数字，合并区间求最小。那么我们的状态就是目前删掉的数字区间，但是我们分割的时候的意思是抽一个卡片出来，所以这个卡片不能在已经抽出的状态里面，所以dp[i][j]里面是不包含j卡片的！我们令dp[i][j]表示抽出第i~j-1张卡片时候的最小值，则状态转移方程如下：

$dp[i][j] = min(dp[i][j],dp[i][k] + dp[k+1][j] +num[i-1]*num[k]*num[j])$

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int dp[105][105];
int num[105];
int main()
{
    int N;
    cin>>N;
    memset(dp,0x3f,sizeof(dp));//dp初始化为inf,因为找最小值
    for(int i = 1;i<=N;i++){
        cin>>num[i];
        dp[i][i] = 0;//dp[i][i]要初始化，作为由小到大累计的初始条件，自己取出自己就是为0
    }
    for(int len = 1;len<=N;len++){
        for(int i = 2;i+len<=N+1;i++){//起点从2开始，因为不包括两端点
            int j = i+len-1;
            for(int k = i;k<j;k++){
                dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j]+num[i-1]*num[k]*num[j]);
            }
        }
    }
    cout<<dp[2][N]<<endl;//由dp[i][j]的定义，输出合并第2~N-1个卡片的结果
    return 0;
}

3. 整数划分（四）

出两个整数 n , m ,要求在 n 中加入m - 1 个乘号，将n分成m段，求出这m段的最大乘积

这里给的乘号是有限个，所以状态方程里必须包含使用乘号的个数，此外还要包含区间长度。所以怎么用二维dp实现包含m和n，我们可以用dp[i][j]表示在第1~i个字符里插入j个乘号的最大值。我们令dp[i][j]表示在第1~i个字符里插入j个乘号的最大值，用num[i][j]表示第i~j个字符表示的数字。则状态转移方程如下：

$dp[i][j] = max(dp[i][j],dp[k][j-1]*num[k+1][i])$

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
ll dp[50][50];
ll num[50][50];
int main()
{
    int T;
    scanf("%d",&T);
    char s[100];
    while(T--)
    {
        int m;
        scanf("%s%d",s+1,&m);
        int len = strlen(s+1);
        memset(dp,0,sizeof(dp));//初始化dp
        memset(num,0,sizeof(num));
        for(int i = 1; i<=len; i++)
        {

            for(int j = i; j<=len; j++)
            {
                for(int k = i;k<=j;k++){
                    num[i][j]*=10;
                    num[i][j]+=(s[k]-'0');
                }
            }
            dp[i][0] = num[1][i];//初始插入0个乘号时是自己，由小到大累计的基础
        }
        for(int j = 1;j<m;j++){//乘号个数由1~m-1个
            for(int i = 1;i<=len;i++){//结尾坐标（表示长度）
                for(int k = 1;k<i;k++){//分割点插入第j个乘号
                    dp[i][j] = max(dp[i][j],dp[k][j-1]*num[k+1][i]);
                }
            }
        }
        cout<<dp[len][m-1]<<endl;//输出在1~len插入m-1个乘号的结果
    }
    return 0;
}

4. Hdu 4632 最多回文子串

给你一个字符串，求出其最多的可构成的回文字串（不要求连续），注意这里不同的回文字串只要求位置不同即可视为不同，比如 aaaaa 的最多回文子串数目是 31。

用dp[i][j]表示状态，表示i~j里最多的回文字串数目，假设现在我们要求dp[i][j]。首先由前一个状态知，因为区间尽可能大而且状态要在dp[i][j]之前，而且回文子串不要求连续，所以 dp[i][j] = dp[i+1][j] ∪ dp[i][j-1] ，接着由容斥原理得：dp[i+1][j] ∪ dp[i][j-1] = dp[i+1][j] + dp[i][j-1] - dp[i+1][j] ∩ dp[i][j-1] = dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1]

注意这是一个固定的状态，每一个状态都由这个公式推出初始状态，是必须且不可选择地。其次，如果s[i] == s[j]，那么两端单独就可以构成回文子序列，而且与dp[i+1][j]，dp[i][j-1]，dp[i+1][j-1] 中的回文序列又可以构成新的回文序列，所以此时dp[i][j] = dp[i+1][j] ∪ dp[i][j-1] + dp[i+1][j-1] + 1；而dp[i][j]已经更新为 dp[i+1][j] ∪ dp[i][j-1]，所以dp[i][j] = dp[i][j] + dp[i+1][j-1] +1

我们令dp[i][j]表示i~j内最多的回文字串数目，则状态转移方程如下：

$dp[i][j] = \left\{\begin{matrix} dp[i+1][j]+dp[i][j-1]-dp[i+1][j-1],s[i] \neq s[j]\\ dp[i][j]+dp[i+1][j-1]+1,s[i] = s[j] \end{matrix}\right.$

注意这里因为容斥时有减法，所以要先加上模再取模，要不会出现负数。其代码实现如下：

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
char s[1005];
int dp[1005][1005];
int main()
{
    int T;
    scanf("%d",&T);
    int t = 0;
    while(T--){
        t++;
        scanf("%s",s+1);
        memset(dp,0,sizeof(dp));
        int len = strlen(s+1);
        for(int i = 1;i<=len;i++)dp[i][i] = 1;//自己是长度为1的
        for(int l = 1;l<=len;l++){
            for(int i = 1;i+l<=len+1;i++){
                int j = i+l-1;//容斥原理 dp[i][j] = dp[i+1][j]并dp[i][j-1] (因为是自序列可以不连续）
                dp[i][j] = (dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1]+10007)%10007;
                if(s[i] == s[j])dp[i][j]=(dp[i][j]+dp[i+1][j-1] + 1)%10007;//如果两端相等，dp[i][j] = 原来的 + 两端与中间每一个回文也可以构成回文（dp[i+1][j-1]) + 两端单独构成一个回文（1）！！！
            }
        }
        printf("Case %d: %d\n",t,dp[1][len]);

    }
    return 0;
}