区间dp（模板+例题）

最新推荐文章于 2024-10-24 00:05:31 发布

罗马字母3

最新推荐文章于 2024-10-24 00:05:31 发布

阅读量843

点赞数 1

CC 4.0 BY-SA版权

分类专栏：动态规划

本文链接：https://blog.youkuaiyun.com/qq_38995588/article/details/80754239

动态规划专栏收录该内容

4 篇文章

订阅专栏

本文介绍了区间动态规划的概念，强调了先解决小区间最优解再扩展到大区间的思想。文中给出了三个例题：51Nod1021 石子合并、hdu3506 猴子派对、hdu5115 Dire wolf，详细解释了解题思路和状态转移方程。并提到了平行四边形优化技术，用于减少计算复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考博文：区间dp小结（附经典例题）
首先，什么是区间dp？它是干什么的？

先在小区间进行DP得到最优解，然后再利用小区间的最优解合并求大区间的最优解
操作往往涉及到区间合并问题

以上。

模板如下：

//mst(dp,0) 初始化DP数组  
for(int i=1;i<=n;i++)  
{  
    dp[i][i]=初始值  
}  
for(int len=2;len<=n;len++)  //区间长度  
for(int i=1;i<=n;i++)        //枚举起点  
{  
    int j=i+len-1;           //区间终点  
    if(j>n) break;           //越界结束  
    for(int k=i;k<j;k++)     //枚举分割点，构造状态转移方程  
    {  
        dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+1][j]+w[i][j]);  
    }  
}

注意区间的枚举起点。

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

首先，假如合并的次序没有限制，那么我们将每堆石子看成一个叶结点，每次合并的代价为数中结点，采用贪心的策略，则整个合并过程就是一个哈夫曼树的建树过程。

但是这里合并的时候要求每次只能合并相邻的两堆，则贪心这里就会出错了，因此我们采用dp的思想进行求解。

我们用dp[i][j]来表示合并第i堆到第j堆石子的最小代价，那么状态转移方程为：
dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+w[i][j]);

其中w[i][j]表示把两部分合并起来的代价，即从第i堆到第j堆石子个数的和，为了方便查询，我们可以用sum[i]表示从第1堆到第i堆的石子个数和，那么w[i][j]=sum[j]-sum[i-1].

代码如下：

#include <cstdio>  
#include <queue>  
#include <cstring>  
#include <algorithm>  
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 = 205;  
const ll mod = 1e9+7;  
const ll INF = 1e18;  
const double eps = 1e-9;  

int n,x;  
int sum[maxn];  
int dp[maxn][maxn];  

int main()  
{  
    while(~scanf("%d",&n))  
    {  
        sum[0]=0;  
        mst(dp,0x3f);  
        for(int i=1;i<=n;i++)  
        {  
            scanf("%d",&x);  
            sum[i]=sum[i-1]+x;  
            dp[i][i]=0;  
        }  
        for(int len=2;len<=n;len++)  
        for(int i=1;i<=n;i++)  
        {  
            int j=i+len-1;  
            if(j>n) continue;  
            for(int 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]);  
    }  
    return 0;  
}

当然有的时候直接这样裸着O(n^3)会T，所以我们有平行四边形优化版本:

由于状态转移时是三重循环的，我们想能否把其中一层优化呢？尤其是枚举分割点的那个，显然我们用了大量的时间去寻找这个最优分割点，所以我们考虑把这个点找到后保存下来

用s[i][j]表示区间[i,j]中的最优分割点，那么第三重循环可以从[i,j-1)优化到【s[i][j-1],s[i+1][j]】。(这个时候小区间s[i][j-1]和s[i+1][j]的值已经求出来了，然后通过这个循环又可以得到s[i][j]的值)。

代码如下：

#include <cstdio>  
#include <queue>  
#include <cstring>  
#include <algorithm>  
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 = 205;  
const ll mod = 1e9+7;  
const ll INF = 1e18;  
const double eps = 1e-9;  

int n,x;  
int sum[maxn];  
int dp[maxn][maxn];  
int s[maxn][maxn];  

int main()  
{  
    while(~scanf("%d",&n))  
    {  
        sum[0]=0;  
        mst(dp,0x3f);  
        for(int i=1;i<=n;i++)  
        {  
            scanf("%d",&x);  
            sum[i]=sum[i-1]+x;  
            dp[i][i]=0;  
            s[i][i]=i;  
        }  
        for(int len=2;len<=n;len++)  
        for(int i=1;i<=n;i++)  
        {  
            int j=i+len-1;  
            if(j>n) continue;  
            for(int k=s[i][j-1];k<=s[i+1][j];k++)  
            {  
                if(dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]<dp[i][j])  
                {  
                    dp[i][j]=dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1];  
                    s[i][j]=k;  
                }  
            }  
        }  
        printf("%d\n",dp[1][n]);  
    }  
    return 0;  
}

例题2：hdu3506 猴子派对
题意：
问题转化后其实就是环形石子合并，即现在有围成一圈的若干堆石子，其他条件跟其那面那题相同，问合并所需最小代价。
解法：
把前n-1堆石子一个个移到第n个后面，那样环就变成了线，即现在有2*n-1堆石子需要合并，我们只要求下面的式子即可。求法与上面那题完全一样。

这道题在uestc版本上不做平行四边形优化会T。

#include<cstdio>
#include<algorithm>
#include<string.h>
using namespace std;
typedef long long ll;
const int inf = 99999999;
const int maxn = 10000;
int a[maxn];
int sum[maxn], dp[maxn][maxn], s[maxn][maxn];

int main() {
    int n;
    while (scanf("%d", &n) != EOF) {
        for (int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            a[n + i] = a[i];
        }
        for (int i = 1; i <= 2 * n; i++) 
            sum[i] = sum[i - 1] + a[i];
        for (int m = 1; m <= n; ++m) {
            for (int i = 0; i + m - 1 < 2 * n; ++i) {
                int j = i + m - 1;
                if (m == 1) {
                    dp[i][i] = 0;
                    s[i][i] = i;
                }
                else {
                    dp[i][j] = inf;
                    for (int k = s[i][j - 1]; k <= s[i + 1][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];
                            s[i][j] = k;
                        }
                    }
                }
            }
        }
        int ans = inf;
        for (int i = 1; i <= n; ++i) {
            ans = min(ans, dp[i][n + i - 1]);
        }
        printf("%d\n", ans);
    }
    return 0;
}

例题3：hdu5115 Dire wolf
题意：
有一排狼，每只狼有一个伤害A，还有一个伤害B。杀死一只狼的时候，会受到这只狼的伤害A和这只狼两边的狼的伤害B的和。如果某位置的狼被杀，那么杀它左边的狼时就会收到来自右边狼的B，因为这两只狼是相邻的了。求杀掉一排狼的最小代价。

解法：
设dp[i][j]为消灭编号从i到j只狼的代价，那么结果就是dp[1][n]，枚举k作为最后一只被杀死的狼，此时会受到a[k]和b[i-1] b[j+1]的伤害，取最小的即可

可列出转移方程：
dp[i][j]=min(dp[i][j], dp[i][k-1]+dp[k+1][j]+a[k]+b[i-1]+b[j+1]);
dp[i][i]=a[i]+b[i-1]+b[i+1];

代码如下：

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
#include<math.h>
using namespace std;
const int N=220
const int INF=0xfffffff

int main()
{
    int T, n, a[N], b[N], dp[N][N], t=1;
    scanf("%d", &T);
    while(T--)
    {
        memset(a, 0, sizeof(a));
        memset(b, 0, sizeof(b));
        scanf("%d", &n);
        for(int i=1; i<=n; i++)
            scanf("%d", &a[i]);
        for(int i=1; i<=n; i++)
            scanf("%d", &b[i]);
        for(int i=1; i<=n; i++)
        {
            for(int j=i; j<=n; j++)
                dp[i][j]=INF;
     ///       dp[i][i]=a[i]+b[i-1]+b[i+1];
        }
        for(int l=0; l<=n; l++)//注意边界
        {
            for(int i=1; i+l<=n; i++)
            {
                int j=i+l;
                for(int k=i; k<=j; k++)
                {
                    dp[i][j]=min(dp[i][j], dp[i][k-1]+dp[k+1][j]+a[k]+b[i-1]+b[j+1]);
                }
            }
        }
        printf("Case #%d: %d\n", t++, dp[1][n]);
    }
    return 0;
}