动态规划-DP 完整版

动态规划

学完了五大基础dp 做个简单总结

dp特征

动态规划问题首要是找到做题的目的是求最大/小值还是其他；

其二要确定问题的状态转移方程这是关键；

第三为dp数组找到边界、

最后检查是否需要结合其他相关知识如树 dfs等；

别忘了检查多测输入数组变量置零等易错点。

背包dp

以背包为抽象模型主要依据某一条件限制求出另一值的最优解

01背包
只有两个值抽象化为体积和价值要在体积一定的情况下找到价值的最大
状态转移方程：

\[dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]) \]

\(\qquad\,\,\)优化为一维：

\[dp[j]=max(dp[j],dp[j-w[i]]+v[i]) \]

code：

点击查看代码

int w[N],v[N],dp[N];
for(int i=1;i<=n;i++)
    for(int j=Vm;j>=w[i];j--)
        dp[j]=max(dp[j],dp[j-w[i]]+v[i]);

完全背包
在01背包基础上物品没有了数量的限制可以有无数个
状态转移方程总体相同更改了第二层体积循环的顺序
code：

点击查看代码

for(int i=1;i<=n;i++)
    for(int j=w[i];j<=V;j++)
        dp[j]=max(dp[j],dp[j-w[i]]+v[i];

多重背包
在01背包基础上添加了部分可以取n次的物品
此类题思路是在输入时就将数据处理成01背包然后直接套用01背包板子即可
code:

点击查看代码

for(int i=1;i<=n;i++)
{
    int w,v,s;//体积 价值 数量
    int k=1;
    cin>>w>>v>>s;
    while(k<=s)
    {
        ww[++cnt]=k*w;
        vv[cnt]=k*v;
        s-=k;
        k*=2;
    }
    if(s)
    {
        ww[++cnt]=s*w;
        vv[cnt]=s*v;
    }
}
for(int i=1;i<=cnt;i++)
    for(int j=V;j>=ww[i];j--)
        dp[j]=max(dp[j],dp[j-ww[i]]+vv[i]);

混合背包
即01 完全多重背包的综合版
方法是将多重背包转化为01背包求解即可
code：

（偷个懒直接截图了Qwq
分组背包
定体积若干组物品每组物品只能选一个
在读入同时直接进行运算
code:

点击查看代码

scanf("%d%d",&n,&V);//组数 体积
for(int i=1;i<=n;i++)
{
    scanf("%d",&t);//组中物品数
    for(int j=1;j<=t;j++)
        scanf("%d%d",&w[i],&v[i]);
    for(int j=c;j>=0;j--)
//这里要先遍历体积再遍历物品 确保每组物品只取一个
        for(int k=1;k<=t;k++)
        {
            if(j<w[k])continue;
            dp[j]=max(dp[j],dp[j-w[k]]+v[k]);
        }
}

特别的每组最少取一个

题目在这里————code

二维费用背包
即在01背包体积价值两个条件下增加一个抽象为质量的限制条件使结果既不超过背包体积也不超过能承受的最大质量
嗯直接枚举即可
code：

点击查看代码

for(int i=1;i<=n;i++)
    for(int j=V;j>=w[i];j--)
        for(int k=M;k>=m[i];k--)
            dp[j][k]=max(dp[j][k],dp[j-w[i]][k-m[i]]+v[i]);

线性dp

（比较抽象的一种dp 非常依靠玄学

该dp主要指一个状态包含多个维度每个维度上都具有线性变化的阶段（晕晕

我们按例题进行分析

LIS（最长上升序列）
题目在这里
问题很好解决转移方程如下：

\[f[i]=max(f[j]+1) \]

\(\qquad\quad\,\,(0<=j<i,a[j]<a[i])\)
\(\qquad\,\,\)还有一点就是这道题要求输出路径我们还需要添加一个数组来递归输出
code:

点击查看代码

#include<bits/stdc++.h>
#define fo(x,y,z) for(int (x)=(y);(x)<=(z);(x)++)
#define foo(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define fu(x,y,z) for(int (x)=(y);(x)>=(z);(x)--)
#define opop cout<<"-------------------------"<<endl;
using namespace std;
inline int qr(){
char ch=getchar();int x=0,f=1;
for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);
return x*f;
}
#define qr qr()
typedef long long ll;
const int Ratio=0;
const int N=10005;
const int maxx=0x3f3f3f;
int n,ans=0,mo=0;
int dh[N],zl[N],yy[N];
void read()
{
	int x;
	while(scanf("%d",&x)!=EOF)
		dh[++n]=x;
}
void DrRatio()
{
	fo(i,1,n)
	{
		zl[i]=1;
		fo(j,1,i-1)
			if(dh[i]>dh[j]&&zl[i]<zl[j]+1)
			{
				zl[i]=zl[j]+1;
				yy[i]=j;
			}
		if(ans<zl[i])
		{
			ans=zl[i];
			mo=i;
		}
	}
}
void opp(int x)
{
	if(x==0)return;
	opp(yy[x]);
	printf("%d ",dh[x]);
}
void op()
{
	printf("max=%d\n",ans);
	opp(mo);
}
int main()
{
	read();
	DrRatio();
	op();
	return Ratio;
}

拦截导弹
题目在这里
第一问很简单最长不上升子序
第二问需要用到Dilworth定理不多阐述
code：

点击查看代码

    int n,i,cnt=0,j,t;
    while(cin>>a[cnt]){
        cnt++;
    }
    int ans=0;
    for(i=0;i<cnt;i++)
    {
        dp[i]=1;
        for(j=0;j<cnt;j++)
        {
            if(a[i]<=a[j]&&i!=j)
                dp[i]=max(dp[i],dp[j]+1);
        }
        ans=max(ans,dp[i]);
    }
    cout<<ans<<endl;
    memset(dp,0,sizeof dp);
    ans=0;
    for(i=0;i<cnt;i++)
    {
        dp[i]=1;
        for(j=0;j<cnt;j++)
        {
            if(a[i]>a[j]&&i!=j)
                dp[i]=max(dp[i],dp[j]+1);
        }
        ans=max(ans,dp[i]);
    }
    cout<<ans<<endl;

麻烦的聚餐
题目在这里
这道题旨在于将给定的序列用最少的次数变成一个不上升或不下降序列
常规方法可能会超时所以需要加一些优化
首先读入同时倒序存储另一个数组

fo(i,1,n)
    dh[i]=qr,yy[n+1-i]=dh[i];

\(\qquad\,\,\)然后将除dp[0]以外所用dp数组内所有值赋为极大值
\(\qquad\,\,\)按正序和倒序遍历两次取结果中最小的哪一个
code：

点击查看代码

void DrRatio()
{
    fo(i,1,n)
        fo(j,1,3)
        {
            zl[i][j]=maxx;
            fu(k,j,1)
                zl[i][j]=min(zl[i][j],zl[i-1][k]);
            if(j!=dh[i])
                zl[i][j]++;
        }
    fo(i,1,3)
        ans=min(zl[n][i],ans);
    fo(i,1,n)
        fo(j,1,3)
        {
            zl[i][j]=maxx;
            fu(k,j,1)
                zl[i][j]=min(zl[i][j],zl[i-1][k]);
            if(j!=yy[i])
                zl[i][j]++;
        }
    fo(i,1,3)
        ans=min(zl[n][i],ans);
}

打鼹鼠
题目在这里
这道题是个典型dp 判断方式也很简单
方法是定义一个以时间早晚排序的结构体只要两者的距离差不大于时间差即可
code：

点击查看代码

struct mole
{
	int time,x,y;
}dh[N];
bool cmp(mole A,mole B)
{
	return A.time<B.time;
}
bool pd(mole A,mole B)
{
	int tc=A.time-B.time,my=abs(B.y-A.y),mx=abs(B.x-A.x);
	return (mx+my)<=tc?true:false;
}
void read()
{
	n=qr,m=qr;
	fo(i,1,m)
		dh[i].time=qr,dh[i].x=qr,dh[i].y=qr;
	sort(dh+1,dh+m+1,cmp);
}
void DrRatio()
{
	fo(i,1,m)
	{
		zl[i]=1;
		fu(j,i-1,1)
			if(pd(dh[i],dh[j]))
				zl[i]=max(zl[i],zl[j]+1);
		ans=max(ans,zl[i]);
	}
}

区间dp

这类题一般是将原序列化分为若干个区间然后合并得出最优解故也称合并动规

提到区间dp 就不得不联系到贪心区间dp的题一眼看上去都可以用贪心来做但很容易举出反例因此在觉得一道题是贪心的时候先试着举出反例若存在反例则要按区间dp的思想来做

同上这一类也用例题的形式回顾

石子合并问题
题目在这里
乍一眼看上去是贪心但试着算一下很容易发现不对劲
首先题目中石子摆成了一个环因此我们采用扩大数组为原来二倍的方法存数据
然后用前缀和的形式存储到每一位石子的值
状态转移方程为:

\[dp[i][j]=max(dp[i+1][j],dp[i][j-1])+sum[j]-sum[i-1] \]

\(\qquad\,\,\)其中\(j=len+i-1\)
\(\qquad\,\,\)边界为：dp[i][i]=0
\(\qquad\,\,\)最终取值为以每一位为首的环的最大值表达式为：

\[ans=max(ans,dp[i][i+n-1]) \]

code:

点击查看代码

void read()
{
	n=qr;
	memset(rm,0,sizeof rm);
	memset(dh,-1,sizeof dh);
	fo(i,1,n)
	{
		yy[i]=qr;
		rm[i]=rm[i-1]+yy[i];
		dh[i][i]=0;
	}
}
void DrRatio()
{
	fo(i,1,n)
	{
		rm[i+n]=rm[i+n-1]+yy[i];
		dh[i+n][i+n]=0;
	}
	fo(len,2,n)
		fo(i,1,2*n-len)
		{
			int j=len+i-1;
			dh[i][j]=max(dh[i+1][j],dh[i][j-1])+rm[j]-rm[i-1];
		}
	fo(i,1,n)
		maax=max(maax,dh[i][i+n-1]);
}

整数划分
题目在这里
现在看来这是一道明显的区间dp
首先一个a数组用来存储第i到j位的数
然后dp数组前i位分成j部分的最优解
状态转移方程为：

\[dp[i][j]=max(dp[i][j],dp[k][j-1]*a[k+1][i]) \]

\(\qquad\,\,\)其中\(0<=k<i\)
\(\qquad\,\,\)边界为：

\[dp[i][0]=a[0][i] \]

\(\qquad\,\,\)对了这一题还需要输出划分结果因此在状态转移时要使用if判断更改后随机更新y数组的值最后递归输出
code:

点击查看代码

#include<bits/stdc++.h>
#define fo(x,y,z) for(int (x)=(y);(x)<=(z);(x)++)
#define foo(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define fu(x,y,z) for(int (x)=(y);(x)>=(z);(x)--)
#define opop cout<<"-------------------------"<<endl;
using namespace std;
inline int qr(){
char ch=getchar();int x=0,f=1;
for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);
return x*f;}
#define qr qr()
typedef long long ll;
const int Ratio=0;
const int N=105;
const int maxx=0x3f3f3f;
int T;
ll dh[N][N],yy[N][N],zl[N][N];
ll m,ne[N],len;
char s[N];
void read()
{
	memset(yy,-1,sizeof yy);
	memset(zl,-1,sizeof zl);
	ne[0]=0;
	scanf("%s%lld",s,&m);
	m--;
	len=strlen(s);
	fo(i,0,len-1)
	{
		dh[i][i]=s[i]-'0';
		fo(j,i+1,len-1)
			dh[i][j]=dh[i][j-1]*10+s[j]-'0';
	}
	fo(i,0,len-1)
	{
		zl[i][0]=dh[0][i];
		yy[i][0]=-1;
	}
}
void dg(ll x,ll y)
{
	if(yy[x][y]==-1)return;
	ne[++ne[0]]=yy[x][y];
	dg(yy[x][y],y-1);
}
void DrRatio()
{
	fo(i,0,len-1)
		fo(j,1,m)
			fo(k,0,i-1)
				if(zl[k][j-1]!=-1&&zl[k][j-1]*dh[k+1][i]>zl[i][j])
				{
					zl[i][j]=zl[k][j-1]*dh[k+1][i];
					yy[i][j]=k;
				}
}
void op()
{
	printf("%lld\n",zl[len-1][m]);
	dg(len-1,m);
	fo(i,0,len-1)
	{
		printf("%c",s[i]);
		if(ne[0]!=0&&i==ne[ne[0]])
		{
			printf(" ");
			ne[0]--;
		}
	}
	printf("\n");
}
int main()
{
	T=qr;
	while(T--)
	{
		read();
		DrRatio();
		op();
	}
	return Ratio;
}

最大乘积（印象最深的一集写了一上午
题目在这里
看上去与上一题类似但坑点就在于需要用高精度
整体思路大致相同求出i到j位的数然后相乘
因为用到高精度需要记录长度因此我选择定义一个结构体让所有运算在结构体内进行
这次的详解放到代码注释里了~
code：

点击查看代码

#include<bits/stdc++.h>
#define fo(x,y,z) for(int (x)=(y);(x)<=(z);(x)++)
#define foo(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define fu(x,y,z) for(int (x)=(y);(x)>=(z);(x)--)
#define opop cout<<"-------------------------"<<endl;
using namespace std;
inline int qr(){
char ch=getchar();int x=0,f=1;
for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);
return x*f;}
#define qr qr()
typedef long long ll;
const int Ratio=0;
const int N=55;
const int maxx=0x3f3f3f;
int n,m;
char s[N];

struct rm
{
	int len;
	int a[105]={};
}dh[N][N],zl[N][N];
rm sw(rm A)//众所周知 高精度运算需要倒着进行 将A首尾倒置 
{
	int b[105];
	fo(i,0,A.len-1)
	{
		b[i]=A.a[A.len-i-1];
	}
	fo(i,0,A.len-1)
	{
		A.a[i]=b[i];
	}
	return A;
}
rm cheng(rm A,rm B)//高精乘 不必多说 
{
	rm C;
	A=sw(A);
	B=sw(B);
	C.len=A.len+B.len;
	fo(i,0,A.len-1)
		fo(j,0,B.len-1)
		{
			C.a[i+j]+=A.a[i]*B.a[j];
			C.a[i+j+1]+=C.a[i+j]/10;
			C.a[i+j]%=10;
		}
	while(C.a[C.len-1]==0&&C.len>1)C.len--;
	A=sw(A),B=sw(B),C=sw(C);
	return C;
}
rm Bma(rm A,rm B)//比较A与B的大小 为状态转移方程用 
{
	if(A.len>B.len)
		return A;
	else if(A.len<B.len)
		return B;
	else 
	{
		fo(i,0,A.len-1)
			if(A.a[i]>B.a[i])
				return A;
			else if(A.a[i]<B.a[i])
				return B;
		return A;
	}
}
void read()
{
	n=qr,m=qr;
	fo(i,1,n)
		cin>>s[i];
	fo(i,1,n)
	{
		dh[i][i].len=1;//初始化dh存i到i位的数 
		dh[i][i].a[0]=s[i]-'0';
		fo(j,i+1,n)//结论推导：存i到j位的数 
		{
			dh[i][j].len=dh[i][j-1].len+1;
			fo(k,0,dh[i][j-1].len-1)
				dh[i][j].a[k]=dh[i][j-1].a[k];
			dh[i][j].a[dh[i][j-1].len]=s[j]-'0';
		}
	}
}
void DrRatio()
{
	fo(i,1,n)
	{
		zl[i][0]=dh[1][i];//初始化/边界 
		fo(j,1,m)
			fo(k,j,i-1)
			{
				rm Rm=cheng(zl[k][j-1],dh[k+1][i]);
				zl[i][j]=Bma(zl[i][j],Rm);
			}
	} 
}
void op()
{
	fo(i,0,zl[n][m].len-1)
		cout<<zl[n][m].a[i];
}
int main()
{
	read();
	DrRatio();
	op();
	return Ratio;
}

凸多边形的三角剖分
题目在这里
这题难想的点在于状态转移方程
首先设一个多边形上的点为A
dp含义为i到j组成三角形的最小值
故点A后一点A+1必不能与A构成三角形
所以\(dp[A][A+1]=0\)
当然自己和自己也不可能构成三角形
然后在这个多边形上任选一点B
在AB间任选一点C
可以得到：AC间剖成三角形的最小值与CB间剖成三角形的最小值的和再加上三角形ABC的值就是AB间剖分最小值
状态转移方程为：

\[dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]+a[i]*a[j]*a[k]) \]

\(\qquad\,\,\)其中\(j=len+i-1,j<=n;i<k<j\)
code:

点击查看代码

void read()
{
	memset(zl,0x3f,sizeof zl);
	n=qr;
	fo(i,1,n)
		scanf("%lld",&dh[i]);
	fo(i,1,n)
		zl[i][i]=zl[i][i+1]=0;
}
void DrRatio()
{
	fo(len,1,n)
		fo(i,1,n)
		{
			int j=min(len+i-1,n);
			fo(k,i+1,j-1)
				zl[i][j]=min(zl[i][j],zl[i][k]+zl[k][j]+dh[i]*dh[j]*dh[k]);
		}
}

坐标dp

提到坐标第一反应就是图

没错坐标dp是需要存图的但很简单只用邻接矩阵即可

将数据存到图中用遍历的方式找最优解是坐标dp的精髓

传纸条
题目在这里
最经典的一道坐标dp题题面也很清晰
直接来看状态转移方程
三维优化后为：

\[dp[k][i][j]=Max(dp[k-1][i][j],dp[k-1][i-1][j],dp[k-1][i][j-1],dp[k-1][i-1][j-1])+a[k-i][i]+a[k-j][j] \]

\(\qquad\,\,\)k为走的步数
\(\qquad\,\,\)其中\(k<m+n;1<=i<n;i<j<=n\)
code:

点击查看代码

void read()
{
	scanf("%d%d",&m,&n);
	fo(i,1,m)
		fo(j,1,n)
			scanf("%d",&dh[i][j]);
//	memset(zl,0,sizeof zl);
}
int Max(int a,int b,int c,int d)
{
	int e=a;
	if(b>e)e=b;
	if(c>e)e=c;
	if(d>e)e=d;
	return e;
}
void DrRatio()
{
	fo(k,3,m+n-1)
		fo(i,1,n-1)
			fo(j,i+1,n)
			{
				if(k<i+1||k<j+1)continue;
				zl[k][i][j]=Max(zl[k-1][i][j],zl[k-1][i-1][j],zl[k-1][i][j-1],zl[k-1][i-1][j-1])+dh[k-i][i]+dh[k-j][j];
			}
}
void op()
{
	printf("%d\n",zl[m+n-1][n-1][n]);
}

矩阵取数游戏
题目在这里
恶心的点在于状态转移方程很难想
好在它可以将每一行分隔开单独看并且用int128即可解决
状态转移方程如下：

\[dp[j][k]=max(dp[j+1][k]*2+a[i][j],dp[j][k-1]*2+a[i][k]) \]

\(\qquad\,\,\)其中\(1<len<=m;1<=j<=m;k=j+len-1\)
code:

点击查看代码

int n,m,dh[N][N];
__int128 zl[N][N],ans=0;
void print(__int128 a)
{
	if(a>9)
		print(a/10);
	putchar(a%10+'0');
}
void read()
{
	n=qr,m=qr;
	fo(i,1,n)
		fo(j,1,m)
			dh[i][j]=qr;
}
void DrRatio()
{
	fo(i,1,n)
	{
		fo(j,1,m)
			zl[j][j]=dh[i][j];
		fo(l,2,m)
			for(int j=1,k=j+l-1;k<=m;j++,k++)
				zl[j][k]=max(zl[j+1][k]*2+dh[i][j],zl[j][k-1]*2+dh[i][k]);
		ans+=zl[1][m]*2;
	}	
}
void op()
{
	print(ans);
}

免费馅饼
题目在这里
这道题要用结构体存图
此外还有两个关键点：
1>人站在最下面一格所以下落高度要-1
2>不是整数时刻落下的接不到
直接上代码吧
code:

点击查看代码

#include <bits/stdc++.h>
#define fo(x,y,z) for(int (x)=(y);(x)<=(z);(x)++)
#define fu(x,y,z) for(int (x)=(y);(x)>=(z);(x)--)
#define foo(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
using namespace std;
inline int qr()
{
	char ch=getchar();int x=0,f=1;
	for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
	for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);
	return x*f;
}
#define qr qr()
typedef long long ll;
const int Ratio=0;
const int N=1005;
const int maxx=0x7f7f7f7f;
int w,h,cnt,maax=-maxx,ans=0;
int a,b,c,d;
int yy[6]={0,-2,-1,0,1,2};
int zl[N][N];
struct rm
{
	int tt,x,v;
}dh[10*N];
void read()
{
	w=qr,h=qr;h--;
	while(scanf("%d%d%d%d",&a,&b,&c,&d)!=EOF)
	{
		if(h%c!=0)continue;
		dh[++cnt].x=b;
		dh[cnt].v=d;
		dh[cnt].tt=a+ceil(h/c);
	}
}
void DrRatio()
{
	fo(i,1,cnt)
	{
		zl[dh[i].x][dh[i].tt]+=dh[i].v;
		maax=max(maax,dh[i].tt);
	}
	fu(j,maax-1,0)
		fo(i,1,w)
		{
			ans=0;
            fo(k,1,5)
				if(i+yy[k]>0&&i+yy[k]<=w&&zl[i+yy[k]][j+1])
					ans=max(ans,zl[i+yy[k]][j+1]);
			zl[i][j]+=ans;
		}
}
void op()
{
	printf("%d\n",zl[w/2+1][0]);
}
int main()
{
	read();
	DrRatio();
	op();
	return Ratio;
}

三角蛋糕
题目在这里
这道题有个坑如果只按题目给定的0和1来存就会出现虽然数字构成了三角形但是方向是反的从而得到了错误答案
因此要反着推一遍
状态转移方程为：

\[dp[i][j]=min(dp[i±1][j],min(dp[i±1][j±1],dp[i±1][j±2]))+1 \]

\(\qquad\,\,\)注意 i与j的运算符号相反
code：

点击查看代码

#include <bits/stdc++.h>
#define fo(x,y,z) for(int (x)=(y);(x)<=(z);(x)++)
#define fu(x,y,z) for(int (x)=(y);(x)>=(z);(x)--)
#define foo(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
using namespace std;
inline int qr()
{
	char ch=getchar();int x=0,f=1;
	for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
	for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);
	return x*f;
}
#define qr qr()
typedef long long ll;
const int Ratio=0;
const int N=505;
const int maxx=0x7f7f7f7f;
char s[N][N];
int n,ans=0;
int dh[N][N],zl[N][N];
void read()
{
	n=qr;
	fo(i,1,n)
		scanf("%s",s[i]+1);//以1为起点 
}
void DrRatio()
{
	fo(i,1,2*n-1)//第一行特殊处理 
		if(s[1][i]!='1')
			zl[1][i]=1,ans=1;
	fo(i,2,n)
		fu(j,2*(n-i)+1,1)//倒 
		{
			if(s[i][j]!='1')
				zl[i][j]=min(zl[i-1][j],min(zl[i-1][j+1],zl[i-1][j+2]))+1;//上一行左中右都不被损坏 
			if(j&1)
				ans=max(ans,zl[i][j]);
		}
	if(s[n][1]=='1')dh[n][1]=1;
	fu(i,n-1,1)//反着推一遍 
		fu(j,2*(n-i)+1,1)
		{
			if(s[i][j]!='1')
				dh[i][j]=min(dh[i+1][j],min(dh[i+1][j-1],dh[i+1][j-2]))+1;
			if(!(j&1))
				ans=max(ans,dh[i][j]);
		}
}
void op()
{
	printf("%d\n",ans*ans);
}
int main()
{
	read();
	DrRatio();
	op();
	return Ratio;
}

树形dp

算法如其名树形dp是建立在树上的dp

而树不存在回路因此dfs是解决树形dp的主要方法

没有上司的舞会
最简单最经典的树规题
\(dp[i][0]\)表示i没有参会
\(dp[i][1]\)表示i参会
状态转移方程为：
\(dp[x][0]+=max(dp[son[x][i]][0],dp[son[x][i]][1])\)
\(dp[x][1]+=dp[son[x][i]][0]\)
code:

点击查看代码

#include<bits/stdc++.h>
#define fo(x,y,z) for(int (x)=(y);(x)<=(z);(x)++)
#define foo(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define fu(x,y,z) for(int (x)=(y);(x)>=(z);(x)--)
#define opop cout<<"-------------------------"<<endl;
using namespace std;
inline int qr(){
char ch=getchar();int x=0,f=1;
for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
for(;ch>='0'&&ch<='9';ch=getchar())x=(x<<3)+(x<<1)+(ch^48);
return x*f;}
#define qr qr()
typedef long long ll;
const int Ratio=0;
const int N=10005;
const int maxx=0x3f3f3f;
vector<int>so[N];
int n,ro;
int zl[N][2],fx[N],joy[N];
void read()
{
	n=qr;
	fo(i,1,n)	
		joy[i]=qr;
	fo(i,1,n)
	{
		int x=qr,y=qr;
		if(i==n)break;
		fx[x]=1;
		so[y].push_back(x);
	}
}
void rRatio(int x)
{
	zl[x][0]=0;
	zl[x][1]=joy[x];
	for(int i=0;i<so[x].size();i++)
	{
		int a=so[x][i];
		rRatio(a);
		zl[x][0]+=max(zl[a][0],zl[a][1]);
		zl[x][1]+=zl[a][0];
	}
}
void DrRatio()
{
	fo(i,1,n)
		if(!fx[i])
		{
			ro=i;
			break;
		}
	rRatio(ro);
}
void op()
{
	printf("%d\n",max(zl[ro][0],zl[ro][1]));
}
int main()
{
	read();
	DrRatio();
	op();
	return Ratio;
}

三色二叉树
写了这一题的题解
在这里看

大体就这么多了再想到会补充的

制作不易求个推荐(✪ω✪)

posted @ 2024-02-17 17:59 Ratio_Y 阅读(223) 评论(18) 编辑收藏举报

刷新页面返回顶部

Ratio_Y

学习奥赛，坚持到底

动态规划-DP 完整版

动态规划

dp特征

背包dp

线性dp

区间dp

坐标dp

树形dp

公告