区间dp

最新推荐文章于 2025-04-08 17:19:10 发布

原创最新推荐文章于 2025-04-08 17:19:10 发布 · 256 阅读

CC 4.0 BY-SA版权

本文深入探讨区间动态规划（区间DP）的概念与应用，通过解析经典案例，如石子合并问题，详细介绍如何确定状态、初始化DP数组及进行状态转移。此外，文章还介绍了四边形不等式优化技巧，用于提高算法效率，并通过多个实战题目，如回文子序列计数、最长回文子序列求解、序列操作次数最小化等，进一步巩固区间DP的理解与运用。

Part1:总概

区间dp

顾名思义，就是解决一些区间内最优值的问题，通常的时间复杂度为 $n^2$ 或者 $n^3$

大致思路：

首先确定状态
初始化长度为1（or 2,3…具体因题而异）的dp数组的值
然后枚举区间长度，枚举区间的起始点，（有的题目还需要枚举断点）由小区间转移到大区间。
最后 $d p [1] [n]$ 往往就是答案。

Part2:例题精讲

NOI1995 石子合并

思路分析：

贪心~很明显是不行的

好的，那我们还是开始想dp吧。区间dp常用的一个状态就是dp[i][j]表示i~j这个区间的最优值是多少？

我们可以看出题目中这个合并过程，很像是区间dp的一种合并，也就是说 $d p [i] [j]$ 可以由 $d p [i] [k]$ 和 $d p [k + 1] [j]$ 转移过
那么我们自然而然的想到要枚举上一次合并是在哪个位置，也就是断点k，然后进行转
不过，由于这个题目的特殊限制，我们需要记录g[i][j]表示i到j这个区间有多少石子，来进行辅助转移

$f [i] [j] = m i n (f [i] [j], f [i] [k] + f [k + 1] [j] + g [i] [k] + g [k + 1] [j]) (i < = k < = j)$

对于环，我们只需要把整个数组复制一遍，然后在统计答案的时候，把1-n开头的长度为n的区间的答案求一个min 就可以啦

Code

#include<bits/stdc++.h>
using namespace std;   
int n,minl,maxl,f1[300][300],f2[300][300],num[300];  
int s[300];  
int d(int i,int j)
{
    return s[j]-s[i-1];
}  
int main()
{
    cin>>n;
    for(int i=1;i<=n+n;i++)  
    {  
        cin>>num[i]; 
        num[i+n]=num[i];  
        s[i]=s[i-1]+num[i];  
    }  
    for(int p=1;p<n;p++)  
    {  
        for(int i=1,j=i+p;(j<n+n)&&(i<n+n);i++,j=i+p)  
        {  
            f2[i][j]=999999999;  
            for(int k=i;k<j;k++)  
            {  
                f1[i][j]=max(f1[i][j],f1[i][k]+f1[k+1][j]+d(i,j));   
                f2[i][j]=min(f2[i][j],f2[i][k]+f2[k+1][j]+d(i,j));  
            }  
        }  
    }  
    minl=999999999;  
    for(int i=1;i<=n;i++)  
    {  
        maxl=max(maxl,f1[i][i+n-1]);
        minl=min(minl,f2[i][i+n-1]);  
    }
    cout<<minl<<endl<<maxl;
    return 0;  
}

不过，这道题在hdu上（hdu3506）n^3的时间复杂度过不了

那么我们就需要考虑，四边形不等式优化！！

如果有 $f [a] [c] + f [b] [d] < = f [b] [c] + f [a] [d]$
可以理解为一句话，交叉小于包含，即交叉的两个区间，a到c和b到d的值满足小于等于包含的两个区间[bc包含于ad])

则说这个东西满足四边形不等式，当然这个东西可能是dp数组，也可以是其他数组

这里有两个定理

1、如果上述的w函数同时满足区间包含单调性和四边形不等式性质，那么函数dp也满足四边形不等式性质

我们再定义 $s (i, j)$ 表示 $d p (i, j)$ 取得最优值时对应的下标（即 $i \leq k \leq j$ 时，k 处的 dp 值最大，则 $s (i, j) = k$ 此时有如下定理

2、假如 $d p (i, j)$ 满足四边形不等式，那么 $s (i, j)$ 单调，即 $s (i, j) \leq s (i, j + 1) \leq s (i + 1, j + 1)$

那么我们就可以开一个s数组， $s [i] [j]$ 这个数组记录 $i j$ 这个区间的转移的最优点是哪个点

那么枚举断点是时候直接可以从 $s [i] [j - 1] s [i + 1 [j]$ 枚举转移

(1)当函数w[i,j]满足 $w [i, j] + w [i^{'}, j^{'}] < = w [i^{'}, j] + w [i, j^{'}], i < = i^{'} < = j < = j^{'}$ 时，称w满足四边形不等式。

(2)当函数w[i,j]满足 $w [i ’, j] \leq w [i, j ’], i < = i^{'} < = j < = j^{'}$ 时称w关于区间包含关系单调。

很明显的,一开始定义的w[I,j]满足区间包含关系和四边形不等式。

现在我们要证明 $f[I,j]=min{f[I,k]+f[k+1,j]+w[I,j]}{i<=k<j}$ 也满足四边形不等式

我们利用数学归纳法对四边形不等式中的区间长度进行归纳。

证明如下：

当i=i’或j=j’时，不等式显然成立。由此可知，当l≤1时，函数f满足四边形不等式。

下面分两种情形进行归纳证明：

情形1： $i < i ’ = j < j ’$
在这种情形下，四边形不等式简化为如下的不等式： $f [i, j] + f [j, j ’] \leq f [i, j ’] + 0$ ，设 $k=max{p| f[i,j’]=f[i,p-1]+f[p,j’]+w[i,j’] }$ ，再分两种情形 $k \leq j$ 或 $k > j$ 。下面只讨论 $k \leq j$ ， $k > j$ 的情况是类似的。
情形1.1： $k \leq j$ ，此时：
情形1.2： $k > j$ ，略去
情形2： $i < i ’ < j < j ’$
设 $y=max{p | f[i’,j]=f[i’,p-1]+f[p,j]+w[i’,j] }$ ${f[p,j’]+w[i,j’] }$
仍需再分两种情形讨论，即 $z \leq y$ 或 $z > y$ 。下面只讨论 $z \leq y$ ， $z > y$ 的情况是类似的。
情形2.1， $i < z \leq y \leq j$ 。
显然的，我们有：
$f [i, j] + f [i^{'}, j^{'}] < = w [i, j] + f [i, z - 1] + f [z, j] + w [i^{'}, j^{'}] + f [i^{'}, y - 1] + f [y, j^{'}]$
因为w满足四边形不等式，所以：
$f [i, j] + f [i^{'}, j^{'}] < = w [i, j^{'}] + w [i^{'}, j] + f [i^{'}, y - 1] + f [i, z - 1] + f [z, j] + f [y, j^{'}]$
因为 $f [i, j^{'}] + f [i^{'}, j] = w [i, j^{'}] + w [i^{'}, j] + f [i^{'}, y - 1] + f [i, z - 1] + f [y, j] + f [z, j^{'}]$
所以,要证 $f [i, j^{'}] + f [i^{'} j] > = f [i, j] + f [i^{'}, j^{'}]$ ,就要证 $f [z, j] + f [y, j^{'}] < = f [y, j] + f [z, j^{'}]$ 。
因为 $i < z \leq y \leq j$ ,所以区间的长度会在不断地迭代中越变越小，最后归于前面的几种情况。
情形2.1， $i < y \leq z \leq j$ 。证明过程略。
综上所述， $f [i, j]$ 满足四边形不等式。
事实上，对于任意 $f[I,j]=max{f[I,k]+f[k+1,j]+w[I,j]}{i<=k<j}$ ,如果w满足四边形不等式，那么f也满足四边形不等式。
前面千辛万苦证明了f满足四边形不等式，那么它有什么用呢？
之所以要证明四边形不等式，就是为了证明f满足决策单调性，即：
$s [i, j - 1] \leq s [i, j] \leq s [i + 1, j], i \leq j$
其中， $s [I, j]$ 为区间 $[I, j]$ 上的最优决策。
当 $i = j$ 时，单调性显然成立。因此下面只讨论 $i < j$ 的情形。由于对称性，只要证明 $s [i, j] \leq s [i, j + 1]$ 。
令 $f k [i, j] = f [i, k - 1] + f [k, j] + w [i, j]$ 。要证明 $s [i, j] \leq s [i, j + 1]$ ，只要证明对于所有 $i < k \leq k ’ \leq j$ 且 $f k ’ [i, j] \leq f k [i, j]$ ，有： $f k ’ [i, j + 1] \leq f k [i, j + 1]$ 。
事实上，我们可以证明一个更强的不等式

$f k [i, j] - f k ’ [i, j] \leq f k [i, j + 1] - f k ’ [i, j + 1]$

也就是: $f k [i, j] + f k ’ [i, j + 1] \leq f k [i, j + 1] + f k ’ [i, j]$

利用递推定义式将其展开整理可得： $f [k, j] + f [k ’, j + 1] \leq f [k ’, j] + f [k, j + 1]$ ，这正是 $k \leq k ’ \leq j < j + 1$ 时的四边形不等式

综上所述，当 $w$ 满足四边形不等式时，函数 $s [i, j]$ 具有单调性。

因此，我们可以得到一个更优化的转移方程

上述方法利用四边形不等式推出最优决策的单调性，从而减少每个状态转移的状态数，降低算法的时间复杂度。

这样这道题就解决了。

一般的，对于状态转移方程形如： $f[i , j] = opt{f[i , k] + f[k+1 , j]} + w[i , j], i < j$ 的动规,若w满足四边形不等式,则f满足四边形不等式,则f有决策单调性。

Code

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
 
using std::max;
using std::min;
 
const int maxn=300;
 
int base[maxn];
int dp[maxn][maxn],s[maxn][maxn];
int MAX[maxn][maxn];
 
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&base[i]);
        base[i+n]=base[i];
    }
    for(int i=1;i<=n*2;i++)
        base[i]+=base[i-1];
    for(int i=1;i<=n*2;i++)
        s[i][i]=i;
    for(int l=2;l<=n;l++)
        for(int i=1;i<=(n*2)-l+1;i++)
        {
            int j=i+l-1;
            int x=s[i][j-1],y=s[i+1][j];
            dp[i][j]=0x7fffffff;
            MAX[i][j]=max(MAX[i][j-1],MAX[i+1][j])+base[j]-base[i-1];//最大值不满足四边形不等式，但最有决策一定出现在端点处
            for(int k=x;k<=y;k++)
                if(dp[i][k]+dp[k+1][j]+base[j]-base[i-1]<dp[i][j])
                {
                    dp[i][j]=dp[i][k]+dp[k+1][j]+base[j]-base[i-1];
                    s[i][j]=k;
                }
        }
    int ansMin=0x7fffffff,ansMax=0;
    for(int i=1;i<n;i++)
        ansMin=min(ansMin,dp[i][i+n-1]),
        ansMax=max(ansMax,MAX[i][i+n-1]);
    printf("%d\n%d",ansMin,ansMax);
    return 0;
}

hdu4632 **

思路：

大致题意是给定一个字符串，求回文子序列个数，最后的答案要%10007，要求一个n^2的做法

首先定义f数组 $f [l] [r]$ 表示 $l r$ 区间的回文子序列个数， $f [i] [i] = 1$ ;

显然根据容斥原理： $f [l] [r] = f [l] [r - 1] + f [l + 1] [r] - f [l + 1] [r - 1]$ （因为中间的个数会算两遍）;

然后，我们考虑 $s [l] = = s [r]$ 的情况，如果这两个位置相等，那么 $l + 1 r - 1$ 这个区间的所有子序列，都可以加入l和r这两个元素，构成一个新的回文子序列，除此之外 l和r这两个元素也可以构成一个回文子序列

那么 $i f (s [l] = = s [r]) f [l] [r] + = f [l + 1] [r - 1] + 1$ ;
Attention
做减法的时候，可能会有负数，为了使%不出现问题，我们需要先加mod再%mo

Code:

#inclue<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
#define mod 10007
int dp[1005][1005];
char s[1005]
int main()
{
	int t,cas=1;
    cin>>t;
    while(t--)
    {
        cin>>s;
        int len=strlen(s);
        memset(dp,0,sizeof dp);
        for(int i=0;i<len;i++)
            dp[i][i]=1;
        for(int j=0;j<len;j++)
        {
            for(int i=j-1;i>=0;i--)
            {
                dp[i][j]=(dp[i][j-1]+dp[i+1][j]-dp[i+1][j-1]+mod)%mod;
                if(s[i]==s[j])
                    dp[i][j]=(dp[i][j]+dp[i+1][j-1]+1)%mod;
            }
        }
        printf("Case %d: %d\n",cas++,dp[0][len-1]);
    }
    return 0;
}

hdu4745*********

题目大意：

给定一个数列，求一个最长的回文子序列

思路：

我们定义 $f [l] [r]$ 表示l到r区间的最长的回文子序列长度

如果 $s [l] = = s [r]$ 则 $f [l] [r] = f [l + 1] [r - 1] + 2$ ;

不然 $f [l] [r] = m a x (f [l + 1] [r], f [l] [r - 1])$ ;

然后统计答案的时候

因为是环

由于考虑到可以从

同一个点出发，长度为n-1，+1

或者从不同的点出发，长度为n

Code:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
using namespace std;
int s[1005],dp[2005][2005];
int main(){                                     //一个顺时针一个逆时针，并且元素
    int n,i,j,l,ans;                            //相同，因此相当于在环上求最长回
    while(scanf("%d",&n)!=EOF&&n){              //文子序列
        memset(dp,0,sizeof(dp));
        for(i=1;i<=n;i++){
            scanf("%d",&s[i]);
            s[i+n]=s[i];
            dp[i][i]=dp[i+n][i+n]=1;
        }
        for(l=2;l<=2*n;l++){
            for(i=1;i<=2*n-l+1;i++){
                j=i+l-1;
                dp[i][j]=max(dp[i+1][j],dp[i][j-1]);
                if(s[i]==s[j])
                dp[i][j]=max(dp[i][j],dp[i+1][j-1]+2);
            }
        }                                       //当s[i]==s[j]时长度加2
        ans=0;
        for(i=1;i<=n;i++){                      //因为是环，所以起点可能在一个点，
            ans=max(ans,dp[i][i+n-1]);          //这样只需求长度是n-1的再加1即可
            ans=max(ans,dp[i][i+n-2]+1);
        }
        printf("%d\n",ans);
    }
    return 0;
}