YBTOJ 区间dp合集

qwq

石子合并

区间dp模板略。

木板涂色

区间dp，特判 $s[l]=s[r]$ 的时候，可以在染一边颜色的时候顺便染另一边，即 $f[i][j]=min(f[i][j-1],f[i+1][j])$。

一般情况就是像普通的区间dp那样，枚举每个断点，将整个区间染色所用的次数即将两边染色用的次数之和。

    ff(i,1,n) f[i][i]=1;
    ff(len,2,n) ff(i,1,n-len+1){
        int j=i+len-1;
        f[i][j]=1e9;
        if(s[i]==s[j]) f[i][j]=min(f[i][j],min(f[i][j-1],f[i+1][j]));
        ff(k,i,j-1) f[i][j]=min(f[i][j],f[i][k]+f[k+1][j]);
    }

消除木块

写了个平平无奇的区间dp爆零了，看数据发现没算合并三个及以上相同颜色块的情况/kk

要解决这个问题，就要同时考虑到当前颜色块 $i$ 前后和它颜色相同的颜色块，然后就不会做了。

$i$ 之前和它颜色相同的颜色块很好处理，而之后的颜色块还没有遍历到，不妨在原dp数组上加一维 $k$ 表示这是后面有长度为k的相同颜色块时的答案（好巧妙qwq

那么对区间 $[l,r]$，考虑消除第 $r$ 个颜色块有两种方案：直接消除或和前面一段合并消除，就能得到dp转移式（懒得敲就放代码吧：

 inline int dp(int l,int r,int k){
    if(f[l][r][k]) return f[l][r][k];
    if(l>r) return 0;
    f[l][r][k]=dp(l,r-1,0)+(siz[r]+k)*(siz[r]+k);//直接消除
    ff(i,l,r-1){//枚举和前面的哪一段合并消除
        if(col[i]!=col[r]) continue;
        f[l][r][k]=max(f[l][r][k],dp(l,i,siz[r]+k)+dp(i+1,r-1,0));
    }
    return f[l][r][k];
}

棋盘分割

二维区间dp，设 $f[i][x1][y1][x2][y2]$ 为把以 $(x1,y1)$ 为左上角，$(x2,y2)$ 为右下角的矩形分割i次得到的最小值，根据题意，第i次分割只能沿着 $x\in [x1,x2-1]$ 或 $y\in [y1,y2-1]$ 切，沿直线 $x$ 切的时候又分为两种可能：选取上半部分和选取下半部分，沿直线 $y$ 切同理。枚举每种可能，取最小答案即可。

维护一个二维前缀和，时间复杂度 $O(n\times 8^5)$。

#include<cstdio>
#include<iostream>
#include<cmath>
#define ll long long
#define y1 yy
#define y2 yyyy
#define ff(i,s,e) for(int i(s);i<=(e);++i)
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-') f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    return x*f;
}
const int N=10;
int n,a[N][N],sum[N][N];
double f[20][N][N][N][N],ave;
inline double qwq(int x1,int y1,int x2,int y2){
    double x=(sum[x2][y2]-sum[x1-1][y2]-sum[x2][y1-1]+sum[x1-1][y1-1])-ave;
    return x*x/n;
}
signed main(){
    n=read();
    ff(i,1,8) ff(j,1,8) a[i][j]=read();
    ff(i,1,8) ff(j,1,8) sum[i][j]=sum[i][j-1]+sum[i-1][j]-sum[i-1][j-1]+a[i][j];
    ave=sum[8][8]*1.0/n;
    ff(x1,1,8) ff(y1,1,8) ff(x2,1,8) ff(y2,1,8){
        f[1][x1][y1][x2][y2]=qwq(x1,y1,x2,y2);
    }
    ff(i,2,n) ff(x1,1,8) ff(y1,1,8) ff(x2,x1,8) ff(y2,y1,8){
        double res=1e9;
        ff(y,y1,y2-1) res=min(res,min(f[i-1][x1][y1][x2][y]+qwq(x1,y+1,x2,y2),f[i-1][x1][y+1][x2][y2]+qwq(x1,y1,x2,y)));
        ff(x,x1,x2-1) res=min(res,min(f[i-1][x1][y1][x][y2]+qwq(x+1,y1,x2,y2),f[i-1][x+1][y1][x2][y2]+qwq(x1,y1,x,y2)));
        f[i][x1][y1][x2][y2]=res;
    }
    printf("%.3lf",sqrt(f[n][1][1][8][8]));
    return 0;
}

写的时候犯了一个脑瘫错误啊啊啊啊，把转移方程式写成了这样：

ff(y,y1,y2-1) res=min(res,min(f[i-1][x1][y1][x2][y]+qwq(x1,y+1,x2,y2),f[i-1][x1][y][x2][y2]+qwq(x1,y1,x2,y+1)));
ff(x,x1,x2-1) res=min(res,min(f[i-1][x1][y1][x][y2]+qwq(x+1,y1,x2,y2),f[i-1][x][y1][x2][y2]+qwq(x1,y1,x+1,y2)));

加一位置变了，$\min$ 判断的两边变成了两种切割方法，而不是一种切割的两种选取方式，然后 $100->30$ /kel

删数问题

模板，删除区间 $[l,r]$有两种选择：一次性全删和分别删除区间 $[l,k]$及 $[k+1][r]$，区间dp求最大值即可。

恐狼后卫

考虑消去区间 $[l,r]$，必定有 $k\in [l,r]$ 是最后一个被消去的，此时 $[l,r]$ 被 $k$ 分成互不影响的左右两区间，那么这次攻击对于答案的贡献就是左区间的贡献+右区间的贡献+ $k$ 的贡献，而与 $k$ 相邻的必然是 $l-1$ 和 $r+1$，则只需知道消去 $k$ 所用的时间就可以求解。预处理数组 $t$ 表示消去每一只狼所用时间，区间dp时枚举每一个最后被消去的 $k$ 即可求最小答案。

由于第 $i$ 只狼本身的攻击对答案的贡献是定值 $a_i\times t_i$，所以为了简化区间dp可以最后再累计这部分答案。

#include<bits/stdc++.h>
#define ll long long
#define ff(i,s,e) for(int i(s);i<=(e);++i)
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-') f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    return x*f;
}
const int N=405;
int n,atk,a[N],b[N],h[N],t[N];
int f[N][N];
signed main(){
    n=read(),atk=read();
    ff(i,1,n) a[i]=read(),b[i]=read(),h[i]=read();
    ff(i,1,n) t[i]=(h[i]%atk)?h[i]/atk+1:h[i]/atk;
    ff(i,1,n) f[i][i]=(b[i-1]+b[i+1])*t[i];
    ff(len,2,n) ff(i,1,n-len+1){
        int j=i+len-1,sum=b[i-1]+b[j+1];
        f[i][j]=min(f[i][j-1]+t[j]*sum,f[i+1][j]+t[i]*sum);
        ff(k,i+1,j-1) f[i][j]=min(f[i][j],f[i][k-1]+f[k+1][j]+t[k]*sum);
    }
    int ans=f[1][n];
    ff(i,1,n) ans+=a[i]*t[i];
    printf("%d",ans);
    return 0;
}

矩阵取数

将 $n$ 行拆开考虑，设 $f[i][j]$ 为从前往后取了 $i$ 个，从后往前取了 $j$ 个得到的最大得分，那么 $f[i][j]$ 只能由 $f[i-1][j]$ 或 $f[i][j-1]$ 转移到，根据题意dp转移式就很好写了，只需要注意特殊处理 $i=0$ 和 $j=0$ 的情况，防止数组越界。

很ex的是 $m$ 最多为 $80$，在不使用__int 128这种奇技淫巧的情况下需要高精，但是本人由于不是很会用重载运算符等原因 把代码写的很丑，这里就不放了qwq

#include<bits/stdc++.h>
#define int unsigned long long
#define ff(i,s,e) for(int i(s);i<=(e);++i)
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-') f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    return x*f;
}
const int N=85;
int n,m,a[N],f[N][N];
signed main(){
    n=read(),m=read();
    int ans=0;
    ff(o,1,n){
        ff(i,1,m) a[i]=read();
        memset(f,0,sizeof(f));
        ff(i,1,m) f[0][i]=f[0][i-1]+a[m-i+1]*(1<<i);
        ff(i,1,m) f[i][0]=f[i-1][0]+a[i]*(1<<i);
        ff(l,1,m) ff(r,1,m){
            if(l+r>m) continue;
            f[l][r]=max(f[l-1][r]+a[l]*(1<<l+r),f[l][r-1]+a[m-r+1]*(1<<l+r));
        }
        int maxx=0;
        ff(i,0,m) maxx=max(maxx,f[i][m-i]);
        ans+=maxx;
    }
    printf("%llu",ans);
    return 0;
}

生日欢唱

常规思路：设 $f[i][j]$ 表示当前选到第 $i$ 个男生第 $j$ 个女生，所能得到的最大愉悦值，然后……做不出来了。

正解换了一种巧妙的做法：设 $f[i][j]$ 表示当前选到第 $i$ 个男生第 $j$ 个女生，且第i个男生和第j个女生必须配对，所能达到的最大愉悦值。

观察数据范围，由于 $a_i$ 和 $b_i$ 都不小于0，所以一定不存在 $i$ 前不选一段男生且 $j$ 前不选一段女生的情况，因为只要在这两段不选的人中任意进行男女配对，得到的最大愉悦度一定不会更小。

所以在求 $f[i][j]$ 的时候，只有三种转移情况：第 $i-1$ 个男生和第 $j-1$ 个女生恰好配对、第 $i$ 个男生前面不选一段，第 $j$ 个女生前面不选一段。枚举不选的那段的长度，就可以 $O(n^3)$ 求解。

由于最优解不一定必须选第 $n$ 个男生和第 $n$ 个女生配对，所以不能直接用 $f[n][n]$ 作为答案。考虑加入第 $n+1$ 个男生和第 $n+1$ 个女生，使 $a_{n+1}=b_{n+1}=0$，所求 $f[n+1][n+1]$ 即为答案。

初始化：对于 $i\ne 0$，$f[i][0]$ 和 $f[0][i]$ 都是不合法的，所以要初始化为 $-inf$。

#include<bits/stdc++.h>
#define int long long
#define ff(i,s,e) for(int i=s;i<=(e);++i)
using namespace std;
inline int read(){
	int x=0,f=1;
	char ch=getchar();
	while(ch>'9'||ch<'0'){if(ch=='-') f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
	return x*f;
}
const int N=305;
int n,a[N],b[N],f[N][N],suma[N],sumb[N];
inline int qwq(int x){return x*x;}
signed main(){
	n=read();
	ff(i,1,n) a[i]=read();
	ff(i,1,n) b[i]=read();
	ff(i,1,n) suma[i]=suma[i-1]+a[i],sumb[i]=sumb[i-1]+b[i];
	ff(i,1,n) f[i][0]=f[0][i]=-1e17;
	ff(i,1,n+1) ff(j,1,n+1){
		f[i][j]=f[i-1][j-1]+a[i]*b[j];
		ff(k,0,j-2) f[i][j]=max(f[i][j],f[i-1][k]+a[i]*b[j]-qwq(sumb[j-1]-sumb[k]));
		ff(k,0,i-2) f[i][j]=max(f[i][j],f[k][j-1]+a[i]*b[j]-qwq(suma[i-1]-suma[k]));
	}
	printf("%lld",f[n+1][n+1]);
	return 0;
}

最小代价

设 $f[l][r][i][j]$ 表示区间 $[l,r]$ 内未消掉的最小值是 $i$，最大值是 $j$ 所需要的最小代价，$g[l][r]$ 表示区间 $[l,r]$ 全部被消掉所需要的最小代价，那么枚举 $l,r,i,j$ 以及分割点 $k$，则有三种情况：

• 未消去的全在左半区间；
• 未消去的全在右半区间；
• 未消去的左右区间都有。

分别dp转移即可。

所以为什么为什么 $O(n^5)$ $3e8$能跑过1s时限啊

#include<bits/stdc++.h>
#define ll long long
#define ff(i,s,e) for(int i=s;i<=(e);++i)
using namespace std;
inline int read(){
	int x=0,f=1;
	char ch=getchar();
	while(ch>'9'||ch<'0'){if(ch=='-') f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
	return x*f;
}
const int N=52;
int n,a,b;
int x[N],y[N];
int f[N][N][N][N],g[N][N];
inline int qwq(int x){return x*x;}
signed main(){
	n=read(),a=read(),b=read();
	ff(i,1,n) x[i]=y[i]=read();
	sort(x+1,x+n+1);
	int m=unique(x+1,x+n+1)-x-1;
	ff(i,1,n) y[i]=lower_bound(x+1,x+m+1,y[i])-x;
//	ff(i,1,n) cout<<y[i]<<' ';cout<<endl;
	memset(f,0x3f3f3f3f,sizeof(f));
	memset(g,0x3f3f3f3f,sizeof(g));
	ff(i,1,n){
		g[i][i]=a;
		ff(j,1,y[i]) ff(k,y[i],m) f[i][i][j][k]=0;
	}
	ff(len,2,n) ff(l,1,n-len+1){
		int r=l+len-1;
		ff(i,1,m) ff(j,i,m) ff(k,l,r){
			int &res=f[l][r][i][j];
			res=min(res,g[l][k]+f[k+1][r][i][j]);
			res=min(res,g[k+1][r]+f[l][k][i][j]);
			res=min(res,f[l][k][i][j]+f[k+1][r][i][j]); 
			g[l][r]=min(g[l][r],res+a+b*qwq(x[j]-x[i]));
		}
	}
	printf("%d",g[1][n]);
	return 0;
}