一本通提高篇 树形动态规划

先写个考试 鸽着~
考试有树$dp$紫题 我回来了
每年联赛基本都有好几道题时树$dp$，这块一定得好好学
$UPD:20201109$期中考砸 回来补博客$qaq$ 先把例题发上去 后面习题一天补上

一、基本概念

树形动态规划，顾名思义，就是在“树”的数据结构上做动态规划，通过有限次地遍历树，记录相关信息，以求解问题，通常都是建立在图上的。线性的动态规划的顺序有向前向后两种方向，即顺推和逆推；而树形动态规划是建立在树上的，树中的父子关系天然就是个递归(子问题)结构，所以也相应的有两个方向。
①叶$\to$根，即根的子节点传递有用的信息给根，之后由根得出最优解的过程。这种方式$DP$的题目应用比较多。
②根$\to$叶，即需要取所有点作为一次根节点进行求值，此时父节点得到了整棵树的信息，只需要去除这个儿子的$DP$值的影响，然后再转移给这个儿子，这样就能达到根$\to$叶的顺序。
实现方式：树形$DP$是通过记忆化搜索实现的，因此采用的是递归方式。
时间复杂度：树形$DP$的时间复杂度基本上是$O(n)$，若有附加维$m$则是$O(nm)$

二、经典问题

1.树的重心

定义$1:$找到一个点，其所有子树中最大的子树结点数最少，那么这个点就是这棵树的重心
定义$2:$以这个点为根，其所有的子树大小都不超过整棵树的一半，那么这个点就是这棵树的重心
$Solution:$任选一个结点为根，把无根树变成有根树，然后设$f_i$表示以$i$为根的子树的结点的个数，则$f[i]=\sum _{j\in son[i]}+1$。结点$i$的子树中最大的有 m a x j ∈ s o n [ i ] { f [ j ] } max_{j∈son[i]}\{f[j]\} maxj∈son[i]​{f[j]}个结点，$i$的祖宗有$n-f[i]$个结点，就能求出删去结点$i$后的最大连通块了
实现：只需一次$DFS$，在无根树转有根树的同时计算即可。
性质$1:$树中所有点到某个点的距离和中，到重心的距离和是最小的；如果有两个重心，那么他们的距离和相等。
性质$2:$把一棵树添加或删除一个子叶，树的重心最多只移动一条边的距离。
性质$3:$把两棵树通过一条边相连得到一颗新的树，那么新的树的重心在原来两个树的重心的路径上。

只求树的重心果题还是挺难找的 看这道$poj$的题吧

poj1655 Balancing Art

题面
题意：求树的重心，并输出删去重心后的最大子树结点数
我注册了个$poj$账号哈哈，$poj$好像不支持万能库？？
裸题 上代码

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
#define N 20020
#define reg register
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
struct node{
	int to,nxt;
}edge[N<<1];
int u,v,n,T,ans,cnt,head[N],siz[N],son[N];
inline void addedge(int u, int v){
	edge[++cnt].to=v,edge[cnt].nxt=head[u],head[u]=cnt;
}
inline void superadd(int u, int v){
	addedge(u,v),addedge(v,u);
}
void dfs(int u, int fa){
	siz[u]=1;
	for(reg int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==fa)continue;
		dfs(v,u);
		siz[u]+=siz[v],son[u]=max(son[u],siz[v]);
	}
	son[u]=max(son[u],n-siz[u]);
	if(son[u]<son[ans])ans=u;
	else if(son[u]==son[ans]&&u<ans)ans=u;
}
int main(){
	read(T);
	while(T--){
		read(n);
		memset(siz,0,sizeof siz);
		memset(son,0,sizeof son);
		memset(head,0,sizeof head);
		cnt=ans=0,son[0]=999999999;
		for(reg int i=1;i<n;i++)read(u),read(v),superadd(u,v);
		dfs(1,0);
		printf("%d %d\n",ans,son[ans]);
	}
}

2.树的直径

这里不得不$diss$一下$sb$一本通，直径两个字一笔没提，求法就给一个
定义:一棵树中，任意两个点的最短路径的距离最大值即为树的直径
有两种求法
$1.$两次$dfs:$实质是遍历点
$2.$树形$dp:$实质是遍历边

求法$1:$两次$dfs$$($或两次$bfs$$)$
做法：先从任意一点$P$开始，找到距离他最远的点$Q$；再从$Q$找到距离最远的点$W$，$QW$即为树的直径

证明：①若$P$是直径上的一点，则$Q$是直径的端点，$QW$就是直径
②若$P$不在直径上，反证法：
假设$QW$不是直径，$AB$是直径，则$Q$一定不在直径上
$(1)$当$AB$与$PQ$有交点时，如图（为了方便把$AB$和$PQ$画成直线）

我们选的$Q$是距离$P$最远的点，则$PQ>PO+OA$
两边同时减去$PO$得$OQ>OA$
两边同时加上$OB$得$OQ+OB>AB$，与$AB$是直径矛盾
$(2)$当$AB$与$PQ$没有交点时，如图
$PQ>NP+NM+NB$，两边同时减去$NP$，得$NQ>NM+MB$
两边同时加上$AM+MN$，得$AM+MN+NQ>AM+2NM+MB>AM+MB=AB$
与$AB$为直径矛盾
故$Q$在直径上，且为直径的端点，所以$QW$为直径
来个板子题

FZOJ 3398 树的直径

题目描述
树的直径：树上两点之间的最大距离。
给出一个树，让你求树的直径。
输入
一个数n表示节点数，以下（n-1）行每行两个数x，y表示x与y间有边。
输出
一个整数，树的直径。
样例输入
10
2 8
7 2
2 1
1 10
2 3
3 4
4 9
3 5
3 6
样例输出
5
提示
40% n<=2000
100% n<=200000

上代码

#include<bits/stdc++.h>
using namespace std;
#define N 200020
#define reg register
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
int n,u,v,p,q,cnt,dep[N],head[N];
struct node{
	int to,nxt;
}edge[N<<1];
inline void addedge(int u, int v){
	edge[++cnt].to=v,edge[cnt].nxt=head[u],head[u]=cnt;
}
inline void superadd(int u, int v){
	addedge(u,v),addedge(v,u);
}
void dfs(int u, int fa){
	dep[u]=dep[fa]+1;
	for(reg int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==fa)continue;
		dfs(v,u);
	}
	if(dep[u]>dep[q])q=u;
}
int main(){
	read(n);
	for(reg int i=1;i<n;i++)read(u),read(v),superadd(u,v);
	dep[0]=-1;dfs(1,0);
	p=q,q=0;
	memset(dep,0,sizeof dep);
	dep[0]=-1;dfs(p,0);
	printf("%d\n",dep[q]);
}

求法$2:$树形$dp$
这个方法也可以适用于有权值的树

一棵有根树的最长连，可能出现红色或黄色两种情况的直径
所以要解决这个问题，我们要求出每个结点为根的子树中的最长链，取其中的最大值为该树的直径
设$dp1[u]$表示以$u$为根的子树中，$u$到叶子结点的距离最大值；$dp2[u]$表示以$u$为根的子树中，$u$到叶子节点的距离次大值
当遍历到$i$的儿子$j$时，
①若$dp1[j]+dis[i][j]>dp1[i]$，则$dp2[i]=dp1[i],dp1[i]=dp1[j]+dis[i][j]$
②若$dp2[i]<dp1[j]+dis[i][j]<dp1[i]$，则$dp2[i]=dp1[j]+dis[i][j]$
最后扫描所有的结点，找最大的$dp1[i]+dp2[i]$的值
上代码
就不找例题了 好累 哭哭

void dfs(int u, int fa){
	for(reg int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==fa)continue;
		dfs(v,u);
		if(dp1[u]<dp1[v]+edge[i].val)
			dp2[u]=dp1[u],dp1[u]=dp1[v]+edge[i].val;
		else if(dp2[u]<dp1[v]+edge[i].val)
			dp2[u]=dp1[v]+edge[i].val;
		ans=max(ans,dp1[u]+dp2[u]);
	}
}

三、一本通题目

行 知识点就这么多够了 来上题吧
书里的例题分为五个题型
$1.$由根分成左子树和右子树两部分的情况
$2.$背包类树形$DP$
$3.$求树的最长链问题
$4.$覆盖一棵树上所有边
$5.$覆盖一棵树上的所有点
就一个一个按顺序来了

题型$1.$二叉苹果树

题面

#include<bits/stdc++.h>
using namespace std;
#define N 110
#define reg register
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
int n,q,u,v,w,cnt,a[N],head[N],ls[N],rs[N],dp[N][N];
struct node{
	int to,nxt,val;
}edge[N<<1];
inline void addedge(int u, int v, int w){
	edge[++cnt].to=v,edge[cnt].val=w,edge[cnt].nxt=head[u],head[u]=cnt;
}
inline void superadd(int u, int v, int w){
	addedge(u,v,w),addedge(v,u,w);
}
void build(int u, int fa){
	int g=0;
	for(reg int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==fa)continue;
		if(!g)ls[u]=v,a[v]=edge[i].val,g++;
		else rs[u]=v,a[v]=edge[i].val;
		build(v,u);
	}
}
int dfs(int u, int num){
	if(!num)return 0;
	if(!ls[u]&&!rs[u])return a[u];
	if(dp[u][num])return dp[u][num];
	for(reg int k=0;k<num;k++)
		dp[u][num]=max(dp[u][num],dfs(ls[u],k)+dfs(rs[u],num-k-1)+a[u]);
	return dp[u][num];
}
int main(){
	read(n),read(q);
	for(reg int i=1;i<n;i++)read(u),read(v),read(w),superadd(u,v,w);
	build(1,0);
	printf("%d\n",dfs(1,q+1));
}

题型$2.$选课

题面
$Solution:$树$dp+$背包
首先，肯定要从没有先修课的课开始选，所以要从跟$0$相连的边开始选。
故直接将$0$设为根就可以了，结点数变为$n+1$
设$dp[u][t]$表示在$x$为根的子树中选$t$门课能够获得的最高学分
这就转化成了一个背包问题
倒序枚举空间 $($即选课总门数$)$ 正序枚举物品$($即传递给子树的选课门数$)$
状态转移方程: d p [ u ] [ t ] = m a x j = 0 t { d p [ u ] [ t − j ] + d p [ v ] [ j ] } dp[u][t]=max_{j=0}^{t}\{dp[u][t-j]+dp[v][j]\} dp[u][t]=maxj=0t​{dp[u][t−j]+dp[v][j]}
上代码↓

#include<bits/stdc++.h>
using namespace std;
#define N 110
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
int n,m,u,cnt,head[N],val[N],dp[N][N];
struct node{
	int to,nxt;
}edge[N<<1];
inline void addedge(int u, int v){
	edge[++cnt].to=v,edge[cnt].nxt=head[u],head[u]=cnt;
}
inline void superadd(int u, int v){
	addedge(u,v),addedge(v,u);
}
void dfs(int u, int fa){
	dp[u][1]=val[u];
	for(int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==fa)continue;
		dfs(v,u);
		for(int t=m;t;t--)
			for(int j=0;j<t;j++)
				dp[u][t]=max(dp[u][t],dp[u][t-j]+dp[v][j]);
	}
}

int main(){
	read(n),read(m);
	for(int i=1;i<=n;i++)
		read(u),read(val[i]),superadd(u,i);
	m++;
	dfs(0,-1);
	printf("%d\n",dp[0][m]);
}

题型$3.$数字转换

题面
$Solution:$把可以转化的数和约数和连上边，这样就组成了一棵树。题中要求的最大变换即为树的直径，就用到了上面树的直径的例题。
这题还要判定一个数只能转化为比他小的约数和，所以我们要判断一个边是否能连上，间接地遍历了边集，所以用树形$dp$求直径更为简洁
$($也可以用两次$dfs$，但是上面写了两次$dfs$的题，这道就用树形$dp$叭$)$
$PS:$如果懒得建图一定要注意遍历顺序是从大数到小数！
上代码↓

#include<bits/stdc++.h>
using namespace std;
#define reg register
#define N 50005
int n,ans,a[N],dis1[N],dis2[N];
void dp(){
	for(reg int i=n;i;i--){
		if(a[i]<i){
			if(dis1[i]+1>dis1[a[i]])
				dis2[a[i]]=dis1[a[i]],dis1[a[i]]=dis1[i]+1;
			else if(dis1[i]+1>dis2[a[i]])dis2[a[i]]=dis1[i]+1;
		}
	}
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=2;j<=n/i;j++)a[i*j]+=i;
	}
	dp();
	for(reg int i=1;i<=n;i++)
		if(dis1[i]+dis2[i]>ans)ans=dis1[i]+dis2[i];
	cout<<ans<<endl;
}

题型$4.$战略游戏

题面
不懂一本通上说的什么树的最大独立集，就把他改成覆盖树上所有点了…
$Solution:$
设$dp[u][0]$表示$u$点不放士兵时，以$u$为根的子树最少需要的士兵数
$dp[u][1]$表示$u$点不放士兵时，以$u$为根的子树最少需要的士兵数
那么当$u$点不放士兵时，因为士兵要看到所有的路，所以所有$u$的儿子结点都要放士兵
即$dp[u][0]=\sum _{v\in son[u]}dp[v][1]$
当$u$点放士兵时，$u$的儿子结点放不放士兵都可以，那么加上$dp[u][1]$和$dp[u][0]$中最小的就可以了
即 d p [ u ] [ 1 ] = ∑ v ∈ s o n [ u ] m i n { d p [ v ] [ 0 ] , d p [ v ] [ 1 ] } dp[u][1]=\sum\limits_{v∈son[u]}{min\{dp[v][0],dp[v][1]\}} dp[u][1]=v∈son[u]∑​min{dp[v][0],dp[v][1]}
上代码↓

#include<bits/stdc++.h>
using namespace std;
#define N 1515
#define reg register
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
int u,v,n,m,cnt,head[N],dp[N][2];
struct node{
	int nxt,to;
}edge[N<<1];
inline void addedge(int u, int v){
	edge[++cnt].to=v,edge[cnt].nxt=head[u],head[u]=cnt;
}
inline void superadd(int u, int v){
	addedge(u,v),addedge(v,u);
}
void dfs(int u, int fa){
	dp[u][1]=1;
	for(int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==fa)continue;
		dfs(v,u);
		dp[u][0]+=dp[v][1];
		dp[u][1]+=min(dp[v][0],dp[v][1]);
	}
}
int main(){
	read(n);
	for(reg int i=1;i<=n;i++){
		read(u),read(m);
		for(reg int j=1;j<=m;j++)read(v),superadd(u,v);
	}
	dfs(0,-1);
	printf("%d\n",min(dp[0][0],dp[0][1]));
}

题型$5.$皇宫看守

题面
$Solution:$
这道题和上道题的区别是，上道题是覆盖所有边，这道题是覆盖所有点。
覆盖所有边要用两个状态，而覆盖所有点需要用三个状态
$①$在父结点安排警卫
$dp[u][0]$表示$u$结点在父亲结点可以被看到时，以$u$为根的子树最少需要安排的士兵数
$②$在当前结点安排警卫
$dp[u][1]$表示$u$结点安排警卫时，以$u$为根的子树需要安排的最少士兵数
$③$在子结点安排警卫
$dp[u][2]$表示$u$结点能被它的至少一个子节点看到时，以$u$为根的子树最少需要安排的士兵数

对于$dp[u][0]，$表示$u$结点能被父亲结点看到，这时$u$结点不用安排警卫，子结点要么安排警卫，要么被它的子结点看到，所以有
d p [ u ] [ 0 ] = ∑ v ∈ s o n [ u ] m i n { d p [ v ] [ 1 ] , d p [ v ] [ 2 ] } dp[u][0]=\sum\limits_{v∈son[u]}{min\{dp[v][1],dp[v][2]\}} dp[u][0]=v∈son[u]∑​min{dp[v][1],dp[v][2]}
$(PS.$一本通又双叒叕写错了…$)$

对于$dp[u][1],$表示$u$结点安排了警卫，$u$的儿子$v$可以安排警卫，也可以被子结点看守，还可以被它的父结点$u$看守，所以有
d p [ u ] [ 1 ] = c o s t [ u ] + ∑ v ∈ s o n [ u ] m i n { d p [ v ] [ 0 ] , d p [ v ] [ 1 ] , d p [ v ] [ 2 ] } dp[u][1]=cost[u]+\sum\limits_{v∈son[u]}{min\{dp[v][0],dp[v][1],dp[v][2]\}} dp[u][1]=cost[u]+v∈son[u]∑​min{dp[v][0],dp[v][1],dp[v][2]}
$PS.$不要忘记加上自身的花费$cost[u]$

对于$dp[u][1],$表示$u$能被至少一个子结点看到，此时$u$结点没有被安排警卫，子结点需要安排警卫或被它的后代看到，所以我们要比较这两个方案哪个更优
但问题来了，如果所有的子结点都是被后代看到更优，那么就没有结点看到$u$结点了，这就是为什么我加粗了至少一个，这时候我们就要判断用哪个子结点安排警卫最优
所以当所有的$dp[v][1]>dp[v][2]$时，维护一个 r = m i n v ∈ s o n [ u ] { d p [ v ] [ 1 ] − d p [ v ] [ 2 ] } r=min_{v∈son[u]}\{dp[v][1]-dp[v][2]\} r=minv∈son[u]​{dp[v][1]−dp[v][2]},最后总结果加上$r$的意义是使一个子结点安排警卫来看守$u$结点
所以有
d p [ u ] [ 2 ] = r + ∑ v ∈ s o n [ u ] m i n { d p [ v ] [ 1 ] , d p [ v ] [ 2 ] } dp[u][2]=r+\sum\limits_{v∈son[u]}{min\{dp[v][1],dp[v][2]\}} dp[u][2]=r+v∈son[u]∑​min{dp[v][1],dp[v][2]}
其中 r = m i n { d p [ v ] [ 1 ] − m i n { d p [ v ] [ 1 ] , d p [ v ] [ 2 ] } } r=min\{dp[v][1]-min\{dp[v][1],dp[v][2]\}\} r=min{dp[v][1]−min{dp[v][1],dp[v][2]}}
$PS.$这样写$r$的意思是，如果子结点有安排警卫的，那么$r=0$表示不用补子结点
如果都没有 那么$r=dp[v][1]-dp[v][2]$表示让$v$结点从被子结点看到改为自己安排警卫
我这块理解了很长时间 所以就多码点字 哈哈
上代码↓

#include<bits/stdc++.h>
using namespace std;
#define N 1515
#define reg register
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
int n,m,u,v,cnt,head[N],dp[N][3],c[N];
struct node{
	int to,nxt;
}edge[N<<1];
inline void addedge(int u, int v){
	edge[++cnt].to=v,edge[cnt].nxt=head[u],head[u]=cnt;
}
inline void superadd(int u, int v){
	addedge(u,v),addedge(v,u);
}
void dfs(int u, int fa){
	int r=2e9;dp[u][1]=c[u];
	for(reg int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==fa)continue;
		dfs(v,u);
		dp[u][0]+=min(dp[v][1],dp[v][2]);
		dp[u][1]+=min(dp[v][0],min(dp[v][1],dp[v][2]));
		dp[u][2]+=min(dp[v][1],dp[v][2]),r=min(r,dp[v][1]-min(dp[v][1],dp[v][2]));
	}
	dp[u][2]+=r;
}
int main(){
	read(n);
	for(reg int i=1;i<=n;i++){
		read(u),read(c[u]),read(m);
		for(reg int j=1;j<=m;j++)read(v),superadd(u,v);
	}
	dfs(1,0);
	printf("%d\n",min(dp[1][1],dp[1][2]));
}

后面就是练习题了

加分二叉树

题面
$Solution:$数据范围这么小忍不住用区间$dp$

#include<bits/stdc++.h>
using namespace std;
#define N 50
typedef long long ll;
int n,root[N][N];
ll dp[N][N],ans;
inline void read(ll &x){
	ll s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
void print(int l, int r){
	if(l>r)return ;
	printf("%d ",root[l][r]);
	if(l==r)return ;
	print(l,root[l][r]-1),print(root[l][r]+1,r);
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++)read(dp[i][i]),root[i][i]=i;
	for(int l=1;l<n;l++){
		for(int i=1,j=l+1;j<=n;i++,j++){
			dp[i][j]=dp[i+1][j]+dp[i][i];
			root[i][j]=i;
			for(int k=i+1;k<j;k++){
				ll now=dp[i][k-1]*dp[k+1][j]+dp[k][k];
				if(dp[i][j]<now)dp[i][j]=now,root[i][j]=k;
			}	
		}
	}
	printf("%lld\n",dp[1][n]);
	print(1,n);
}

旅游规划

题面
$Solution:$这道题可能有多条直径，而且要求出所有在直径上的点，所以用树形$dp$求树的直径
还是往常的直径的长度 l e n = m a x { d i s 1 [ i ] len=max\{dis1[i] len=max{dis1[i]和$dis[2]\}$
但是问题来了，如果一个点$u$在直径上，但他只有两条边，一条连向父亲$fa$，一条连向儿子$v$，那么他的$dis2$值会为$0$，但实际上他也在直径上
这个问题的出现的原因是因为我们把$dfs$设成单向，不让一个点去重复遍历他的父亲结点，因为他遍历不了父亲结点，所以才导致$dis2$值为$0$，故我们需要求出此节点在父亲结点方向链长的最大值
如何解决这个问题呢
我们设置两个数组$son1[i]=v$表示$i$点的$dis1[i]$值是从$v$点转移的，$move[i]$表示$i$点在父亲结点方向的链长最大值
分两种情况
$1.$如果$son[fa]=u$：说明$u$就在$fa$求得$dis1$值的链中，转移$move[u]$不能从$dis1$中转移。那么又有两种情况，$fa$有$dis2$和没有$dis2$，所以 m o v e [ u ] = m a x { d i s 2 [ f a ] , m o v e [ f a ] } move[u]=max\{dis2[fa],move[fa]\} move[u]=max{dis2[fa],move[fa]}
$2.$如果$son[fa]\ne u$：这时候转移可以从$dis1$转移了，所以 m o v e [ u ] = m a x { d i s 1 [ f a ] , m o a v [ f a ] } + 1 move[u]=max\{dis1[fa],moav[fa]\}+1 move[u]=max{dis1[fa],moav[fa]}+1
最后判断$m[i]+dis1[i]=len$或$dis1[i]+dis2[i]=len$时说明$i$在直径上
上代码

#include<bits/stdc++.h>
using namespace std;
#define N 200020
#define reg register
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
int n,u,v,ans,cnt,head[N],dis1[N],dis2[N],son1[N],m[N];
struct node{
	int to,nxt;
}edge[N<<1];
inline void addedge(int u, int v){
	edge[++cnt].to=v,edge[cnt].nxt=head[u],head[u]=cnt;
}
inline void superadd(int u, int v){
	addedge(u,v),addedge(v,u);
}
void dfs(int u, int fa){
	for(reg int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==fa)continue;
		dfs(v,u);
		if(dis1[u]<dis1[v]+1)dis2[u]=dis1[u],dis1[u]=dis1[v]+1,son1[u]=v;
		else if(dis2[u]<dis1[v]+1)dis2[u]=dis1[v]+1;
	}
	ans=max(ans,dis1[u]+dis2[u]);
}
void df5(int u, int fa){
	if(u!=1){
		if(son1[fa]==u)m[u]=max(dis2[fa],m[fa])+1;
		else m[u]=max(dis1[fa],m[fa])+1;
	}
	for(reg int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v!=fa)df5(v,u);
	}
}
int main(){
	read(n);
	for(reg int i=1;i<n;i++)read(u),read(v),superadd(++u,++v);
	dfs(1,0);df5(1,0);
	for(reg int i=1;i<=n;i++)if(m[i]+dis1[i]==ans||dis1[i]+dis2[i]==ans)printf("%d\n",i-1);
}

周年纪念晚会

题面
$Solution:$和没有上司的舞会一样
$dp[u][0]$表示$u$不去，$dp[u][1]$表示$u$去
那么
d p [ u ] [ 0 ] = ∑ v ∈ s o n [ u ] m i n { d p [ v ] [ 0 ] , d p [ v ] [ 1 ] } dp[u][0]=\sum\limits_{v∈son[u]}min\{dp[v][0],dp[v][1]\} dp[u][0]=v∈son[u]∑​min{dp[v][0],dp[v][1]}
$dp[u][1]=\sum _{v\in son[u]}dp[v][0]$
代码↓

#include<bits/stdc++.h>
using namespace std;
#define N 6060
#define reg register
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
int n,u,v,cnt,head[N],dp[N][2],a[N];
struct node{
	int to,nxt;
}edge[N<<1];
inline void addedge(int u, int v){
	edge[++cnt].to=v,edge[cnt].nxt=head[u],head[u]=cnt;
}
inline void superadd(int u, int v){
	addedge(u,v),addedge(v,u);
}
void dfs(int u, int fa){
	dp[u][1]=a[u];
	for(reg int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==fa)continue;
		dfs(v,u);
		dp[u][0]+=max(dp[v][0]+dp[v][1]);
		dp[u][1]+=dp[v][0];
	}
}
int main(){
	read(n);
	for(reg int i=1;i<=n;i++)read(a[i]);
	while(1){
		read(u),read(v);
		if(u==0&&v==0)break;
		superadd(u,v);
	}
	dfs(1,0);
	printf("%d\n",max(dp[1][0],dp[1][1]));
}

叶子的颜色$(CQOI2009$叶子的染色$)$

题面
$Solution:$首先一个结点有三种状态:$1.$黑色 $2.$白色 $3.$无色
我们可以发现，叶子结点的染色方案只与上一个有色结点有关
这句话有两个意思
$1.$无色结点与答案无关，因为它做不出任何贡献
$2.$根结点与答案无关，因为答案只与叶子结点的上一个有色结点有关
设$dp[u][0]$为$u$结点染成黑色时，以$u$为根的子树需要的最少代价
$dp[u][1]$为$u$结点染成白色时，以$u$为根的子树需要的最少代价
那么 d p [ u ] [ 0 ] = 1 + ∑ v ∈ s o n [ u ] m i n { d p [ v ] [ 0 ] − 1 , d p [ v ] [ 1 ] } dp[u][0]=1+\sum\limits_{v∈son[u]}min\{dp[v][0]-1,dp[v][1]\} dp[u][0]=1+v∈son[u]∑​min{dp[v][0]−1,dp[v][1]}
d p [ u ] [ 1 ] = 1 + ∑ v ∈ s o n m i n { d p [ v ] [ 0 ] , d p [ v ] [ 1 ] − 1 } dp[u][1]=1+\sum\limits_{v∈son}min\{dp[v][0],dp[v][1]-1\} dp[u][1]=1+v∈son∑​min{dp[v][0],dp[v][1]−1}
初始条件
$dp[u][c[u]]=1,dp[u][!c[u]]=infu\in [1,n]$
$dp[u][0]=1,dp[u][1]=1u\in [n+1,m]$
上代码↓

#include<bits/stdc++.h>
using namespace std;
#define N 10010
#define reg register
#define inf 2000000000
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
int n,m,u,v,cnt,head[N],dp[N][2],c[N];
struct node{
	int to,nxt;
}edge[N<<1];
inline void addedge(int u, int v){
	edge[++cnt].to=v,edge[cnt].nxt=head[u],head[u]=cnt;
}
inline void superadd(int u, int v){
	addedge(u,v),addedge(v,u);
}
void dfs(int u, int fa){
	for(reg int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==fa)continue;
		dfs(v,u);
		dp[u][0]+=min(dp[v][0]-1,dp[v][1]);
		dp[u][1]+=min(dp[v][0],dp[v][1]-1);
	}
}
int main(){
	read(m),read(n);
	for(reg int i=1;i<=n;i++)read(c[i]),dp[i][c[i]]=1,dp[i][!c[i]]=inf;
	for(reg int i=1;i<m;i++)read(u),read(v),superadd(u,v);
	for(reg int i=1+n;i<=m;i++)dp[i][0]=dp[i][1]=1;
	dfs(n+1,0);
	printf("%d\n",min(dp[n+1][0],dp[n+1][1]));
}

骑士

题面
$Solution:$模型是没有上司的舞会的模型，只不过把每个骑士和他烦的骑士连上边，是颗有$n$个结点$n$条边的基环树
那么我们找到环，把环中的一条边断开，那么就变成了一棵树，再对断开的两个结点分别做根进行树$dp$。因为断开的两个结点也是有条件约束的，就强制在一个结点遍历时不遍历另一个结点。
树中会有很多联通块，对每个联通块都进行一次找环的操作，所有答案加起来就是最后的答案
实现时要注意：
$1.$边要连单向边，并存一个$f$数组指向边的反方向，来存储上一个结点的信息
$2.$环只有一个，联通块不是一个，要对每个联通块都求一遍环
$3.ans$要开$longlong$
上代码↓

#include<bits/stdc++.h>
using namespace std;
#define reg register
#define N 1000100
typedef long long ll;
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
ll ans,dp[N][2];
bool vis[N];
int n,u,v,rt,cnt,head[N],c[N],f[N];
struct node{
	int to,nxt;
}edge[N];
inline void addedge(int u, int v){
	edge[++cnt].to=v,edge[cnt].nxt=head[u],head[u]=cnt;
}
void dfs(int u){
	vis[u]=1;
	dp[u][0]=0,dp[u][1]=c[u];
	for(reg int i=head[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==rt)continue;
		dfs(v);
		dp[u][0]+=max(dp[v][1],dp[v][0]);
		dp[u][1]+=dp[v][0];
	}
}
inline void judge(int x){
	rt=x,vis[x]=1;
	while(!vis[f[rt]])rt=f[rt],vis[rt]=true;
	dfs(rt);
	ll p=dp[rt][0];
	vis[rt]=true,rt=f[rt];
	dfs(rt);
	ll q=dp[rt][0];
	ans+=max(p,q);
}
int main(){
	read(n);
	for(reg int i=1;i<=n;i++)read(c[i]),read(v),addedge(v,i),f[i]=v;
	for(reg int i=1;i<=n;i++)if(!vis[i])judge(i);
	printf("%lld\n",ans);
}

四、总结

讲个故事
$CSP2019$前在家跟同学语音刷题，突然发现好多蓝树$dp$题都变成了绿色，我就跟同学提了嘴是不是出题组为了出树$dp$才把标签弄简单的，结果没想到三个树$dp$

总的来说，树形$dp$是一个能解决许多树上问题的一个优秀高效算法，在联赛中也屡见不鲜。
本人$QQ:407694747$，欢迎各位大佬一起来讨论