【学习笔记】区间dp学习笔记

区间动态规划的思想是从小区间转移到大区间，最小的区间直接求解。

通常方程长成 f_{i,j}=operation(f_{i,k},f_{k+1,j})fi,j​=operation(fi,k​,fk+1,j​)。

复杂度通常是 n^3n3 的（枚举长度，枚举左端点，枚举断点）。

luogu P1775 石子合并（弱化版）

直接贪心是行不通的，我们考虑动态规划。

设 f{i,j} 表示区间 [i,j][i,j] 的最优解，那么边界显然是 f_{i,i}=0.

如何转移？我们枚举一个断点 k，其中k <jl≤k<j，表示 [i,j]分割成 [i,k] 和 [k,j]，而这两个区间的解此时已经求出，由题意有转移方程 f{i,j}=min{value(i,j)+f{i,k}+f{k+1,j}}，其中 value(i,j)=∑i≤p≤j​mp​。

回顾上面的过程我们发现我们只要保证大区间内的所有小区间都已经有解即可。

所以我们直接枚举左右端点不可行（除非你写记忆化搜索，但是递归有比较大的常数）。

我们先枚举长度，升序枚举，然后枚举左端点，此时能够做到先小区间，再大区间。

#include <stdio.h>
inline int min(int x,int y)
{
    return x<y?x:y;
}
const int inf=1e9;
int m[305],f[305][305],sum[305];
int main()
{
    int n,i,j,l,k;scanf("%d",&n);
    for(i=1;i<=n;++i)
        for(j=i;j<=n;++j)
            f[i][j]=inf;//初始化数组我习惯 for 循环
    for(i=1;i<=n;++i)
    {
        scanf("%d",m+i);
        sum[i]=sum[i-1]+m[i];//前缀和
        f[i][i]=0;//初始化dp数组，我习惯用 f，有时突然发电用 dp 或者 g 或者 h。
    }
    for(l=1;l<=n;++l)//长度
        for(i=1;i+l-1<=n;++i)//左端点，注意上界
        {
            j=i+l-1;//右端点
            for(k=i;k<j;++k)//枚举一发，实现方程
                f[i][j]=min(f[i][j],f[i][k]+f[k+1][j]+sum[j]-sum[i-1]);
        }
    printf("%d",f[1][n]);
}

luogu P1880 [NOI1995] 石子合并

多了个破环成链。

我们考虑如何处理环，如果每次将头丢到尾，循环 nn 次，复杂度 n^4n4。哈哈哈，这题你就过了。

我们看一下数组变化过程：

容易发现，实际上将数组复制一遍粘到后面就可以了。

然后和上面的没有本质区别啊，只不过最后结果是 max1≤i≤n f{i,i+n-1}

代码有啥好贴的，随便改改就行了。

luogu P3146 [USACO16OPEN]248 G

水题，鉴定为黄题。

依然考虑区间动态规划。

套路的想到，f{i,i}=val,转移为 f{i,j}=max{f{i,k}+1},但是发现一个问题，由于可能最终的答案转移不到 f{1,n}，所以输出 f{1,n}是荒谬绝伦的。

仔细思考一下，显然 res=max {f{i,j}}.

转移的时候判一下即可。

#include <stdio.h>
#include <string.h>
using namespace std;
int _x;
char _c;
inline int read()
{ 
}
int n,i,j,k,l,ans;
int dp[305][305];
inline int max(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    n=read();
    for(i=1; i<=n; i++)dp[i][i]=read();//初始化，别忘了
    for(l=2; l<=n; ++l)
    {
        for(i=1; i+l-1<=n; ++i)
        {//前两层套路的循环
            j=i+l-1;
            for(k=i; k<j; ++k)if(dp[i][k]==dp[k+1][j])ans=max(dp[i][j]=max(dp[i][j],dp[i][k]+1),ans);//压了一下行。先转移 dp[i][j]，转移时更新 ans。
        }
    }
    printf("%d",ans);
    return 0;
}

[ABC163E] Active Infants

叙述我写了好几遍，感觉甚至不如此题题解，于是不放叙述了麻蛋。

#include <stdio.h>
#include <algorithm>
#define int long long
class node{
public:
    int v,pos;
    node(){}
    inline const bool operator<(const node &other)const
    {
        return v<other.v;
    }
}a[20005];
long long f[2005][2005];
signed main(){
    int n,i,l,j;
    scanf("%lld",&n);
    for(i=1;i<=n;i++)
    {
        scanf("%lld",&a[i].v);
        a[i].pos=i;
    }
    std::sort(a+1,a+n+1);
    for(l=1;l<=n;l++)
        for(i=1;i+l-1<=n;i++)
        {
            j=i+l-1;
            f[i][j]=std::max(f[i][j],f[i+1][j]+a[l].v*std::abs(a[l].pos-i));
            f[i][j]=std::max(f[i][j],f[i][j-1]+a[l].v*std::abs(a[l].pos-j));
        }
    printf("%lld\n",f[1][n]);
    return 0;
}