前言
一、简单介绍 (Tree DP)
树形动态规划 ( Tree DP ) 是一种常用的动态规划技巧,跟普通的线性动态规划不同,此算法将DP建立在树状结构或图的基础上,是一种 DP 的思想。
以下是 树形 DP 的一般步骤:
①、定义状态:根据问题的特点,定义每个节点需要保存的状态。可以是最大值、最小值、累加和、路径长度等等。
②、设计转移方程:根据问题的要求,定义每个节点状态之间的转移关系。这个转移关系通常由树的拓扑结构决定,先在每个节点处定义状态,再利用已经计算出的节点状态来计算当前节点的状态。
③、遍历计算:使用深度优先搜索 (DFS)或广度优先搜索(BFS)遍历整个树,按照定义的转移方程计算每个节点的状态。
④、求解最终结果:根据最终状态的定义,从中选择所需的结果,比如最大值、最小值等。
二、代码实现
树形dp 之 选择节点类
例题引入
题目
描述
某大学有 n n n 个职员,编号为 1 … n 1 \ldots n 1…n。
他们之间有从属关系,也就是说他们的关系就像一棵以校长为根的树,父结点就是子结点的直接上司。
现在有个周年庆宴会,宴会每邀请来一个职员都会增加一定的快乐指数
r
i
r_i
ri ,但是呢,如果某个职员的直接上司来参加舞会了,那么这个职员就无论如何也不肯来参加舞会了。
所以,请你编程计算,邀请哪些职员可以使快乐指数最大,求最大的快乐指数。
输入格式
输入的第一行是一个整数
n
n
n 。
第 2 到第
(
n
+
1
)
(n+1)
(n+1) 行,每行一个整数,第
(
i
+
1
)
(i+1)
(i+1) 行的整数表示
i
i
i 号职员的快乐指数
r
i
r_i
ri 。
第
(
n
+
2
)
(n+2)
(n+2) 到第
2
n
2n
2n 行,每行输入一对整数
l
,
k
l , k
l,k ,代表
k
k
k 是
l
l
l 的直接上司。
输出格式
输出一行一个整数代表最大的快乐指数。
输入/输出样例
输入 #1
7
1
1
1
1
1
1
1
1 3
2 3
6 4
7 4
4 5
3 5
输出 #1
5
说明/提示
数据规模与约定
对于 100 % 100\% 100% 的数据,保证 1 ≤ n ≤ 6 × 1 0 3 , − 128 ≤ r i ≤ 127 , 1 ≤ l , k ≤ n 1 \le n \le 6×10^3 , −128 \le r_i \le 127, 1 \le l,k \le n 1≤n≤6×103,−128≤ri≤127,1≤l,k≤n,且给出的关系一定是一棵树。
思路
先浅浅地说说选择节点类的一般转移方程:
{
f
u
,
0
=
f
v
,
1
f
u
,
1
=
max
/
min
(
f
v
,
0
,
f
v
,
1
)
.
\begin{cases} f_{u,0}=f_{v,1} \\ f_{u,1}=\max/\min(f_{v,0},f_{v,1}) \end{cases}.
{fu,0=fv,1fu,1=max/min(fv,0,fv,1).
选择节点式的题首先前提条件是整个数据是由树形结构存储的,或者应该用树形结构存,运行的效率更高,而且相邻的节点是不能同时存在的,最后要求取最大最小值 。
I.建立树
用链式前向星建树,这里是储存一棵树,所以每两个结点之间只需要建立一条边,即等同于有向无环图。
k
k
k 创建一条边连接指向
l
l
l,代表
k
k
k 是
l
l
l 的直接上司。
我们还需要统计每个结点的入度,如果当前的结点的入度为
0
0
0 ,则此结点必定是这棵树的根节点(root)。
II. dfs 遍历整棵树
借助链式前项星遍历整棵树。
此处用一个数组
f
f
f 来记录当前子节点的状态。
f
u
,
0
表示
u
不去
f_{u,0}表示 u 不去
fu,0表示u不去
f
u
,
1
表示
u
去
f_{u,1}表示 u 去
fu,1表示u去
状态转移方程如下:
{
f
u
,
0
+
=
max
(
f
v
,
0
,
f
v
,
1
)
;
u
不去,那么它的子节点(直接下属)可去可不去,取其最大值即可
f
u
,
1
+
=
f
v
,
0
;
u
去了那么它的子节点一定不能去,直接加
.
\begin{cases} f_{u,0}+=\max(f_{v,0},f_{v,1}); u不去,那么它的子节点(直接下属)可去可不去,取其最大值即可\\ f_{u,1}+=f_{v,0}; u去了那么它的子节点一定不能去,直接加 \end{cases}.
{fu,0+=max(fv,0,fv,1);u不去,那么它的子节点(直接下属)可去可不去,取其最大值即可fu,1+=fv,0;u去了那么它的子节点一定不能去,直接加.
最后找到根节点, a n s = max ( f r o o t , 0 , f r o o t , 1 ) ans=\max(f_{root,0},f_{root,1}) ans=max(froot,0,froot,1)。
Code
#include<bits/stdc++.h>
using namespace std;
const int N=6001;
int n,h[N],l,k,root;
struct Edge {
int v,nxt;
}edge[N<<1];
int head[N],idx;
int f[N][3],degree[N];
void add(int x,int y) { //邻接表建图
edge[++idx].v=y;
edge[idx].nxt=head[x];
head[x]=idx;
}
void dfs(int u,int fa) { //进行树形dp
f[u][0]=0,f[u][1]=h[u];
for(int i=head[u];i;i=edge[i].nxt) { //遍历当前结点u的子节点v
int v=edge[i].v;
dfs(v,u); //继续向下dfs遍历
f[u][0]+=max(f[v][1],f[v][0]); //父节点由子节点转移过来
f[u][1]+=f[v][0]; //若上司不去,下属可以选择去不去;反之,上司去,下属就不去
}
}
int main() {
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&h[i]);
for(int i=1;i<n;i++) {
scanf("%d%d",&l,&k);
add(k,l); //有向边构图,有直属关系,
degree[l]++; //记录入度
}
for(int i=1;i<=n;i++) { //寻找根节点
if(degree[i]==0) {
root=i;
break;
}
}
dfs(root,0);
printf("%d\n",max(f[root][0],f[root][1])); //取最大值
return 0;
}
类似的选择节点类的经典例题还有 洛谷 P2016 战略游戏 等
树形dp 之 树的直径类(有些超纲)【图论•算法】
树的直径,(Diameter of a Tree),又称树的最长链,定义为一棵树上最远的两个节点的路径,即树上一条不重复经过某一条边的最长的路径。树的直径也可以代指这条路径的长度,树是以邻接表存无向边的形式储存的。
在树上寻找树的直径(最长链)的方法:
前提:此做法只有在权值为正数的情况下才能使用。
1). 对于任意一点,假设这个结点为
a
a
a ,那么,我们需要找到离
a
a
a 最远的结点(如果不在同一棵子树上,通常为叶子结点)
x
x
x 。
2). 再对
x
x
x 结点,继续搜索寻找最远的结点
y
y
y .
3). 最后,从
x
x
x 出发到
y
y
y 结点的整条路径就是这棵树的直径之一。
注意:一棵树的所有直径的长度(边权值总和) 都一样。
对于此处,大家可能会放出疑问,或者你已经理解了,但你只是模糊的明白,还不能很好的证明,本蒟蒻也是学得一脸蒙,最后只能搬大佬的详细证明,再结合自我理解,最通俗地讲述给大家。
F1 证明(反证大法)
假设此树的最长路径是从
s
s
s 到
t
t
t ,我们选择的点为
u
u
u 。
假设搜到的点是
v
v
v ,分两种情况讨论。
1、结点
v
v
v 在这条最长路径(即树的直径)上,那么
d
i
s
t
u
,
v
>
d
i
s
t
u
,
v
+
d
i
s
t
v
,
s
dist_{u,v}>dist_{u,v}+dist_{v,s}
distu,v>distu,v+distv,s ,显然矛盾。
2、结点
v
v
v 不在直径上,且
(
u
,
v
)
(u,v)
(u,v) 和
(
s
,
t
)
(s,t)
(s,t) 有公共点
p
p
p,如图所示:
此时
d
i
s
t
u
,
v
>
d
i
s
t
v
,
t
=
d
i
s
t
u
,
p
>
d
i
s
t
t
,
p
dist_{u,v} > dist_{v,t}=dist_{u,p} > dist_{t,p}
distu,v>distv,t=distu,p>distt,p ,
则
d
i
s
t
u
,
s
>
d
i
s
t
s
,
t
=
d
i
s
t
u
,
s
>
d
i
s
t
u
,
v
dist_{u,s}>dist_{s,t}=dist_{u,s}>dist_{u,v}
distu,s>dists,t=distu,s>distu,v ,此时
(
s
,
t
)
(s,t)
(s,t) 不是树的直径,于已知矛盾。
3、节点
v
v
v 不在这条最长路径上,即
(
s
,
t
)
(s,t)
(s,t) 和
(
u
,
v
)
(u,v)
(u,v) 没有公共点,在最长路径上任意选择一个点为
p
p
p ,则
d
i
s
t
u
,
v
>
d
i
s
t
u
,
p
+
d
i
s
t
p
,
t
dist_{u,v}>dist_{u,p}+dist_{p,t}
distu,v>distu,p+distp,t ,那么有
d
i
s
t
s
,
v
←
d
i
s
t
s
,
p
+
d
i
s
t
p
,
u
+
d
i
s
t
u
,
v
>
d
i
s
t
s
,
p
+
d
i
s
t
p
,
t
→
d
i
s
t
s
,
t
dist_{s,v} \gets dist_{s,p}+dist_{p,u}+dist_{u,v}>dist_{s,p}+dist_{p,t} \to dist_{s,t}
dists,v←dists,p+distp,u+distu,v>dists,p+distp,t→dists,t ,即
d
i
s
s
,
v
>
d
i
s
s
,
t
dis_{s,v}>dis_{s,t}
diss,v>diss,t ,矛盾。
综上所述,经过两次的
d
f
s
dfs
dfs 求出最长路径的两个端点和其的路径长度便是树的直径。
F2 证明(交换论证大法):
!!大佬做法!!
s
s
s 是树的某个直径
a
a
a 的端点。假设
x
x
x 的最远和第二远的点组成的链是
b
b
b ,
b
b
b 就会和
a
a
a 有一段公共部分。我们取
a
a
a 和
b
b
b 相交部分距离
s
s
s 最远的那个点
y
y
y 。那么取这个链上点
y
y
y 的答案一定比
x
x
x 更优。
经典模板题 洛谷转载自SPOJ PT07Z - Longest path in a tree
题目描述
给你一个无权无向的树。编写程序以输出该树中最长路径(从一个节点到另一个节点)的长度。在这种情况下,路径的长度是我们从开始到目的地的遍历边数。
输入格式
输入文件的第一行包含一个整数
N
N
N ——树中的节点数。
接下来
N
−
1
N−1
N−1 行包含该树的
N
−
1
N−1
N−1 个边—每行包含一对
(
u
,
v
)
(u,v)
(u,v) ,表示在节点
u
u
u 和节点
v
v
v 之间存在边。
输出格式
输出最长路径的长度。
输入/输出样例
输入 #1
3
1 2
2 3
输出 #1
2
说明/提示
对于 100 % 100\% 100% 的数据, 1 ≤ N ≤ 1 0 4 1 \le N \le 10^4 1≤N≤104 , 1 ≤ u , v ≤ N 1 \le u,v \le N 1≤u,v≤N 。
Code(权值无负,全正)
如果权值全部都为不为负数,即任意结点 a i ≥ 0 a_i \geq 0 ai≥0 ,则可用上述方法,进行两次 d f s dfs dfs 找出最远的两个节点即可。
#include<bits/stdc++.h>
using namespace std;
const int N=1e4+10;
int n,x,y;
struct Edge {
int v,nxt;
}edge[N<<1];
int head[N],idx;
int dist[N];
void add(int x,int y) {
e[++idx].v=y;
e[idx].nxt=head[x];
head[x]=idx;
}
void dfs(int u,int step) {
if(dist[u]!=0) return ;
dist[u]=step;
for(int i=head[u];i;i=edge[i].nxt) {
int v=edge[i].v;
dfs(v,step+1);
}
}
int main() {
scanf("%d",&n);
for(int i=1;i<n;i++) {
scanf("%d%d",&x,&y);
add(x,y),add(y,x);
}
dfs(1,1);
int maxx=0,k=0;
for(int i=1;i<=n;i++)
if(dist[i]>maxx) maxx=dis[i],k=i;
memset(dist,0,sizeof(dist));
dfs(k,1);
maxx=0;
for(int i=1;i<=n;i++)
maxx=max(dist[i],maxx);
printf("%d\n",maxx-1);
return 0;
}
题目描述
给定一棵树,树中包含
n
n
n 个结点(编号
1
∼
n
1 ∼ n
1∼n )和
n
−
1
n−1
n−1 条无向边,每条边都有一个权值。
现在请你找到树中的一条最长路径。
换句话说,要找到一条路径,使得路径两端的点的距离最远。
注意:路径中可以只包含一个点。
输入格式
第一行包含整数
n
n
n。
接下来
n
−
1
n−1
n−1 行,每行包含三个整数
a
i
,
b
i
,
c
i
a_i , b_i , c_i
ai,bi,ci ,表示点
a
i
a_i
ai 和
b
i
b_i
bi 之间存在一条权值为
c
i
c_i
ci 的边。
输出格式
输出一个整数,表示树的最长路径的长度。
输入/输出样例
输入 #1
6
5 1 6
1 4 5
6 3 9
2 6 8
6 1 7
输出 #1
22
说明/提示
数据规模与约定
对于 100 % 100\% 100% 的数据,保证 1 ≤ n ≤ 10000 1≤n≤10000 1≤n≤10000 , 1 ≤ a i , b i ≤ n 1≤a_i,b_i≤n 1≤ai,bi≤n , − 1 e 5 ≤ c i ≤ 1 e 5 −1e5≤c_i≤1e5 −1e5≤ci≤1e5 。
Code (权值有负)
此处蒟蒻一开始并没有用树形dp去做,思想是对于树上的任意结点,都对其找最远
d
1
d1
d1 和次远
d
2
d2
d2 的结点,一边遍历,一边打擂台比大小,找最长的路径长度。
为什么此处不能直接二次
d
f
s
dfs
dfs 呢,是由于我们的
d
f
s
dfs
dfs 是对树的各个结点的深度进行储存,如果有负边权,就会影响
d
i
s
t
[
]
dist[]
dist[] 的答案,使得最后的答案会不正确(蒟蒻的个人想法,欢迎各位大佬斧正~~) 。
#include<bits/stdc++.h>
using namespace std;
const int N=1e6;
int n,a,b,c,ans;
struct Edge {
int v,nxt;
int w;
}edge[N<<1];
int head[N],idx;
void add(int x,int y,int z) {
edge[++idx].v=y;
edge[idx].nxt=head[x];
edge[idx].w=z;
head[x]=idx;
}
int dfs(int u,int fa) {
int d1=0,d2=0,dist=0;
for(int i=head[u];i;i=edge[i].nxt) {
int v=edge[i].v;
int w=edge[i].w;
if(v==fa) continue;
int d=dfs(v,u)+w;
dist=max(d,dist);
if(d>d1) {
d2=d1;
d1=d;
} else if(d>d2) d2=d;
}
ans=max(d1+d2,ans);
return dist;
}
int main() {
scanf("%d",&n);
for(int i=1;i<n;i++) {
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
add(b,a,c);
}
dfs(1,0);
printf("%d\n",ans);
return 0;
}
但为了凸显我们信息学的举一反三的优良学习精神,我们就大方的开个数组。
其实也没什么用,反正空间爆不了。
下面是改进的代码 (啥也不是) :
#include<bits/stdc++.h>
using namespace std;
const int N=1e6;
int n,h[N],a,b,c,ans;
struct Edge {
int v,nxt;
int w;
}edge[N<<1];
int head[N],idx;
int f[N];
void add(int x,int y,int z) {
edge[++idx].v=y;
edge[idx].nxt=head[x];
edge[idx].w=z;
head[x]=idx;
}
int dfs(int u,int fa) {
int d1=0,d2=0;
for(int i=head[u];i;i=edge[i].nxt) {
int v=edge[i].v;
int w=edge[i].w;
if(v==fa) continue;
int d=dfs(v,u)+w;
f[u]=max(d,f[u]);
if(d>d1) {
d2=d1;
d1=d;
} else {
if(d>d2)
d2=d;
}
}
ans=max(d1+d2,ans);
return f[u];
}
int main() {
scanf("%d",&n);
for(int i=1;i<n;i++) {
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
add(b,a,c);
}
dfs(1,0);
printf("%d\n",ans);
return 0;
}
拓展
树的中心为“到所有点的最大距离“最小的节点。而定义树的“几何中心”,除了在节点上,还可以处于某条边中。那么有性质:
当边权为正时,所有直径都经过(几何)中心。
证明:
显然,几何中心可以把树分为多棵子树,而一条直径经过几何中心当且仅当这条直径的两端点在不同子树中。容易看出,若一条直径的两端在同一子树中,那么将此时的“伪几何中心”向这课子树方向移动显然只会让这个最大距离进一步变小。
如图,显然有
(
m
,
y
)
<
(
x
,
y
)
≤
min
(
(
u
,
x
)
,
(
v
,
x
)
)
<
min
(
(
m
,
u
)
,
(
m
,
v
)
)
(m,y)<(x,y)\le \min((u, x), (v,x))< \min((m,u),(m,v))
(m,y)<(x,y)≤min((u,x),(v,x))<min((m,u),(m,v)) 。
显然,若所有直径经过几何中心,则所有直径要么都经过某条边及其两端点(其中至少一个为中心),要么经过中心,证毕。
树形dp 之 树形背包类
请让蒟蒻说说树形背包类的一般转移方程:
{
f
v
,
k
=
f
u
,
k
+
a
v
f
u
,
k
=
max
(
f
u
,
k
,
f
v
,
k
−
1
)
.
\begin{cases} f_{v,k}=f_{u,k}+a_v\\ f_{u,k}=\max(f_{u,k},f_{v,k-1}) \end{cases}.
{fv,k=fu,k+avfu,k=max(fu,k,fv,k−1).
树形背包,就是背包加上条件,在树上进行背包选择,一个物品只有选择了它的主件(父亲结点) 才能选择。
题目来源 洛谷P2015 苹果树
题目描述
有一棵苹果树,如果树枝有分叉,一定是分二叉(就是说没有只有一个儿子的结点)
这棵树共有
N
N
N 个结点(叶子点或者树枝分叉点),编号为
1
∼
N
1∼N
1∼N,树根编号一定是
1
1
1。
我们用一根树枝两端连接的结点的编号来描述一根树枝的位置。下面是一颗有
4
4
4 个树枝的树:
2 5
\ /
3 4
\ /
1
现在这颗树枝条太多了,需要剪枝。但是一些树枝上长有苹果。
给定需要保留的树枝数量,求出最多能留住多少苹果。
输入格式
第一行
2
2
2 个整数
N
N
N 和
Q
Q
Q ,分别表示表示树的结点数,和要保留的树枝数量。
接下来
N
−
1
N−1
N−1 行,每行
3
3
3 个整数,描述一根树枝的信息:前
2
2
2 个数是它连接的结点的编号,第
3
3
3 个数是这根树枝上苹果的数量。
输出格式
一个数,最多能留住的苹果的数量。
说明/提示
1 ⩽ Q < N ⩽ 100 1⩽Q<N⩽100 1⩽Q<N⩽100,每根树枝上的苹果 ⩽ 3 × 1 0 4 ⩽3×10^4 ⩽3×104。
解题思路
经分析,本题需要在树上进行动态规划,故使用树形dp。
I.建立树
任何相邻的两个节点没有优先级关系,所以用邻接表储存树,如果把这棵树看做一个图,即是无向无环连通图,此处不用多讲,比较简单实现。
II.dp 随着 dfs 动规整棵树
此题已明确给出了根节点为
1
1
1,我们就无需多开一个
d
e
g
r
e
e
[
]
degree[]
degree[] 数组来找入度为
0
0
0 的结点了,直接进行遍历。
状态转移方程:
f
i
,
j
f_{i,j}
fi,j 表示以
i
i
i 为结点的子树,保留
j
j
j 个树枝,最多能留住的苹果数量
f
u
,
j
=
max
(
f
u
,
j
,
f
u
,
j
−
k
−
1
+
f
v
,
k
+
w
)
f_{u,j}=\max(f_{u,j},f_{u,j-k-1}+f_{v,k}+w)
fu,j=max(fu,j,fu,j−k−1+fv,k+w)
当前状态可从以子节点
v
v
v 为根的子树保留
k
k
k 个树枝的苹果数量
f
v
,
k
f_{v,k}
fv,k,加上本身结点
u
u
u 剩下
j
−
k
−
1
j-k-1
j−k−1 个树枝保留的苹果数量,这里多减的一个
1
1
1 是因为要保留
u
u
u,
v
v
v 之间相连的连边,也即
f
u
,
j
−
k
−
1
f_{u,j-k-1}
fu,j−k−1 转移过来。
注意:
i
i
i,
j
j
j需要倒序枚举,因我们此处进行的是01背包。
Code
#include<bits/stdc++.h>
using namespace std;
const int N=1001;
int n,q,a,b,c;
struct Edge {
int v,w,nxt;
}edge[N<<1];
int head[N],idx;
int f[N][N];
void add(int x,int y,int z) {
edge[++idx].v=y;
edge[idx].nxt=head[x];
edge[idx].w=z;
head[x]=idx;
}
void dfs(int u,int fa) {
for(int i=head[u];i;i=edge[i].nxt) {
int v=edge[i].v;
int w=edge[i].w;
if(v==fa) continue;
dfs(v,u);
for(int j=q;j>=0;j--) {
for(int k=0;k<j;k++)
f[u][j]=max(f[u][j],f[u][j-k-1]+f[v][k]+w);
}
}
}
int main() {
scanf("%d%d",&n,&q);
for(int i=1;i<n;i++) {
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
add(b,a,c);
}
dfs(1,0);
printf("%d\n",f[1][q]);
return 0;
}
树形dp的 n^2 优化
本题如果需要优化时间的话,需要在进行动态规划的循环进行上下界限优化,
(
1
≤
i
≤
min
(
q
,
s
z
u
)
,
0
≤
j
≤
min
(
s
z
v
,
i
−
1
)
)
( 1 \le i \le \min(q,sz_u),0 \le j \le \min(sz_v,i−1) )
(1≤i≤min(q,szu),0≤j≤min(szv,i−1))
我在做题一开始没意识到可以优化,所以code程序没有进行优化,大家可以自行修改。
再拿 洛谷P2014 选课 这道经典的树形dp例题来讲,抛开题目,如果学某个课程前不只需要学其他的一个课程,而是一些课程(课程数目
≥
2
≥ 2
≥2,即每个结点的入度最多为
1
1
1 ),这样更好理解优化。
首先上两个都可以过本题的代码,以方便作比较。
Code
#include<bits/stdc++.h>
using namespace std;
const int N=301;
int n,m,a,b[N];
struct Edge {
int v,nxt;
}edge[N<<1];
int head[N],idx;
int f[N][N];
void add(int x,int y) {
edge[++idx].v=y;
edge[idx].nxt=head[x];
head[x]=idx;
}
void dfs(int u) {
f[u][1]=b[u];
for(int i=head[u];i;i=edge[i].nxt) {
int v=edge[i].v;
dfs(v);
for(int j=m+1;j>=0;j--) {
for(int k=0;k<j;k++)
f[u][j]=max(f[u][j],f[u][j-k]+f[v][k]);
}
}
}
int main() {
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) {
scanf("%d%d",&a,&b[i]);
add(a,i);
}
dfs(0);
printf("%d\n",f[0][m+1]);
return 0;
}
Code 2 (优化)
#include<bits/stdc++.h>
using namespace std;
const int N=301;
int n,m,a,b[N];
struct Edge {
int v,nxt;
}edge[N<<1];
int head[N],idx;
int f[N][N],sz[N];
void add(int x,int y) {
edge[++idx].v=y;
edge[idx].nxt=head[x];
head[x]=idx;
}
void dfs(int u) {
f[u][1]=b[u];
sz[u]=1;
for(int i=head[u];i;i=edge[i].nxt) {
int v=edge[i].v;
dfs(v);
for(int j=min(m+1,sz[u]+sz[v]);j>=0;j--) {
for(int k=0;k<=min(sz[v],j-1);k++)
f[u][j]=max(f[u][j],f[u][j-k]+f[v][k]);
}
sz[u]+=sz[v];
}
}
int main() {
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) {
scanf("%d%d",&a,&b[i]);
add(a,i);
}
dfs(0);
printf("%d\n",f[0][m+1]);
return 0;
}
小总结
通过对比观察两次的数据,可以发现两个代码在用时上有差距,而且这是在
1
≤
N
≤
300
1 \le N \le 300
1≤N≤300 这么小的数据下比较,如果
n
=
1000
n=1000
n=1000 甚至
10000
10000
10000 的时候呢。
从程序上来看最主要的差别在于进行dp操作的两个循环的范围 :
程序 1 的 main part
for(int j=m+1;j>=0;j--) {
for(int k=0;k<j;k++)
f[u][j]=max(f[u][j],f[u][j-k]+f[v][k]);
}
程序 2 的 main part
for(int j=min(m+1,sum[u]+sum[v]);j>=0;j--) {
for(int k=0;k<=min(sum[v],j-1);k++)
f[u][j]=max(f[u][j],f[u][j-k]+f[v][k]);
}
这乍一看,好像没啥差别。
可是你不能小看了这步操作,他可起了很大的作用,光表面说是没用的。
但如果用大佬的一大堆数学结论方法证明,我们这些小蒟蒻是看不懂的 。
那就用最通俗易懂 的方法来解释吧。
我们把这两个循环做的事看作是两组数进行乘法原理的匹配,
s
u
m
u
sum_u
sumu:以结点
u
u
u 为根节点的子树的结点个数
此处的
s
u
m
u
sum_u
sumu 是以当前访问结点为根的子树的大小(包括当前根结点),其实是个非常小的常数,这里做解释时为了方便,暂时省略,但在优化程序时不能省略(可能会导致 WA 出错),因为自己也可以从本身所处的子树集里的节点转移状态过来。
而每次匹配操作都会出现和以前不一样的数对。
当访问完所有结点后,所得出来的全部数对都不重复。
这样时间复杂度就可以转换为了一个组合问题:
C
2
n
=
n
∗
(
n
−
1
)
2
C_{2}^{n}=\frac{n*(n-1)}{2}
C2n=2n∗(n−1)
再加上原来省略的常数,就接近
O
(
n
2
)
O(n^2)
O(n2) 的时间复杂度了。
大佬的严格证明,感兴趣的数学大佬可以尝试去理解,本蒟蒻就不参与了。
这里的优化省略了常数,其实当
n
n
n 很大时,这个常数也比较大,经过我和我校的几位大佬的一番讨论,虽然接受全网大佬们严格的证明,优化后肯定是平方级别的时间复杂度,但是经过试验,如果样例故意卡,那么这个省略的常数还是不可估量的大 (虽然还是比
n
3
n^3
n3 快上不少) 。
所以在做树形dp的题型时,我们尽量做到能优化就优化,尽量想办法把时间复杂度从
O
(
n
3
)
O(n^3)
O(n3) 压缩到
O
(
n
2
)
O(n^2)
O(n2) 平方级。
总结
给定一棵有N个节点的树(通常是无根树,也就是有
N
−
1
N-1
N−1 条无向边),我们可以任选一个节点为根节点,从而定义出每个节点的深度和每棵子树的根。
在树上设计动态规划算法时,一般就以节点从深到浅(子树从小到大)的顺序作为dp的“阶段”。在状态表示中,第一维通常是节点编号(代表以该节点为根的子树)。大多数时候,我们采用递归的方式实现树形动态规划。对于每个节点
u
u
u ,先递归在它的每个子节点上进行动态规划dp,在回溯时,从子节点向节点
u
u
u 进行状态转移。
最主要的题型主要用于:
①.选择节点类
②.树形背包类
③.树的直径类
题库
可以先浅浅练练基础 ,建议可以参考一下我的学习题单 洛谷【树形dp】 ID:970993
如有侵权,请联系一下我,说明情况,如属实,我会立即撤回文章!
你的点赞加收藏将是我最大的动力哦!
如有问题或指点欢迎评论,关注加私聊!
谢谢大佬们的观看!拜拜!