文章目录

• 树形dp
• • 概述
  • 树形dp + 路径问题
  • • 树的最长路径
    • • 思路
      • 代码
    • 树的中心
    • • 换根DP
      • 思路
      • 代码
    • 数字转换
    • • 思路
      • 代码
  • 树形dp + 有依赖的背包
  • • 二叉苹果树
    • • 思路
      • 代码
  • 树形dp + 状态机
  • • 没有上司的舞会
    • • 思路
      • 代码
    • 战略游戏
    • • 思路
      • 代码
    • 皇宫看守
    • • 思路
      • 代码
  • 总结

概述

树形dp + 路径问题

树的最长路径

思路

代码

N, M = 10010, 10010 * 2
h = [-1] * N
e = [0] * M
w = [0] * M
ne = [-1] * M
idx = 0
d1, d2 = [0] * N, [0] * N
ans = 0

def add(a, b, c) :
	global idx
	e[idx] = b
	w[idx] = c
	ne[idx] = h[a]
	h[a] = idx
	idx += 1

def dfs(u, father) :
	global ans
	i = h[u]
	while i != -1 :
		j = e[i]
		if j != father
			dfs(j, u)
			#最长路径和次长路径的逻辑
			if d1[u] <= d1[j] + w[i] :
				d1[u], d2[u] = d1[j] + w[i], d1[u]
			elif d2[u] < d1[j] + w[i] :
				d2[u] = d1[j] + w[i]
		i = ne[i]
	ans = max(ans, d1[u] + d2[u]) #找到以u为中心的最长路径
	

n = int(input())

for i in range(n - 1) :
	a, b, c = map(int, input().split())
	add(a, b, c), add(b, a, c) #无向边

dfs(1, -1)#任意取一个点为根节点
print(ans)

树的中心

换根DP

此类题目特点是，给定一个树形结构，需要以每个节点为根进行一系列统计。我们一般通过两次扫描来求解此类题目。

1. 第一次扫描时，任取一个点为根，在“有根树”上执行一次树形DP，也就是在回溯时发生的、自底向上的状态转移。
2. 第二次扫描时，从刚才选出的根出发，对整棵树执行一次深度优先遍历，在每次递归前进行自顶向下的推导，计算出“换根”后的解。

思路

代码

N, M = 10010, 20010
h = [-1] * N
e = [0] * M
w = [0] * M
ne = [-1] * M
idx = 0
d1, d2, s, up= [0] * N, [0] * N, [0] * N, [0] * N

def add(a, b, c) :
	global idx
	e[idx] = b
	w[idx] = c
	ne[idx] = h[a]
	h[a] = idx
	idx += 1
#记录每个节点的最长距离和次长距离，以及最长距离的子节点编号
def dfs_d(u, father) : 
	i = h[u]
	while ~ i :
		j = e[i]
		if j != father :
			dfs_d(j, u)
			if d1[u] <= d1[j] + w[i] :
				d1[u], d2[u], s[u] = d1[j] + w[i], d1[u], j
			elif d2[u] < d1[j] + w[i] :
				d2[u] = d1[j] + w[i]
		i = ne[i]
# 处理每个节点途经父节点的最长距离
def dfs_u(u, father) :
	i = h[u]
	while ~ i :
		j = e[i]
		if j != father :
			if j != s[u] : up[j] = max(up[u], d1[u]) + w[i]
			else : up[j] = max(up[u], d2[u]) + w[i]
			dfs_u(j, u)
		i = ne[i]

n = int(input())

for i in range(n - 1) :
	a, b, c = map(int, input().split())
	add(a, b, c), add(b, a, c)

dfs_d(1, -1) # 任取一个点为根
dfs_u(1, -1) # 从刚才选出的根出发，对整棵树执行一次深度优先遍历

res = 10000010
for i in range(1, n + 1) :
	res = min(res, max(d1[i], up[i]))
	
print(res)

数字转换

思路

代码

N = 50010
h = [-1] * N
e = [0] * N
ne = [-1] * N
idx = 0
cumu = [0] * N
st = [False] * N
ans = 0
d1, d2 = [0] * N, [0] * N

def add(a, b) :
	global idx
	e[idx] = b
	ne[idx] = h[a]
	h[a] = idx
	idx += 1

def dfs(u) : #求最长路径
	global ans
	i = h[u]
	while ~ i :
		j = e[i]
		dfs(j)
		if d1[u] <= d1[j] + 1 :
			d1[u], d2[u] = d1[j] + 1, d1[u]
		elif d2[u] < d1[j] + 1 :
			d2[u] = d1[j] + 1
		i = ne[i]
	ans = max(ans, d1[u] + d2[u])

n = int(input())

# 筛法求约数
for i in range(1, n + 1) : #枚举所有两两相乘的情况，记录其中约数，除去本身
	for j in range(2, n // i + 1) :
		cumu[i * j] += i

for i in range(2, n + 1) : #1没有父节点
	if i > cumu[i] :
		add(cumu[i], i)
		st[i] = True

for i in range(1, n + 1) :
	if not st[i] : #枚举根节点
		dfs(i)

print(ans)

树形dp + 有依赖的背包

二叉苹果树

思路

状态表示：
集合：设f[x, t]表示在以x为根的子树中选t个树枝能够保留的苹果数的集合
属性：集合中的苹果数的最大值
状态计算：
设x的子节点集合为Son(x)，子节点个数p = ∣ S o n ( x ) ∣ p = |Son(x)|p=∣Son(x)∣。保留x这个节点后，对于x的每个节点y i ∈ S o n ( x ) y_i \in Son(x)yi​∈Son(x),我们可以在以y i y_iyi​根节点的子树上选择保留若干节点(记数量为c i c_ici​)，在满足∑ i = 1 p c i = t \sum_{i=1}^pc_i = t∑i=1p​ci​=t
f [ x , t ] = m a x ( ∑ i = 1 p f [ y i , c i ] ) + w [ x , y i ] ,   ( ∑ i = 1 p c i = t ) f[x, t] = max(\sum_{i=1}^pf[y_i, c_i]) + w[x, y _ i], \ ( \sum_{i = 1}^pc_i = t)f[x,t]=max(i=1∑p​f[yi​,ci​])+w[x,yi​], (i=1∑p​ci​=t)
该方程其实是一个分组背包模型。有p = ∣ S o n ( x ) ∣ p = |Son(x)|p=∣Son(x)∣组物品，每组物品都有t个，其中第i组的第j个物品的体积为j，价值为f [ y i , j ] f[y_i, j]f[yi​,j]，背包的总体积为t。

代码

N, M = 110, 210
h = [-1] * N
e = [0] * M
ne = [0] * M
w = [0] * M
idx = 0
f = [[0] * N for _ in range(N)]

def add(a, b, c) :
	global idx
	e[idx] = b
	w[idx] = c
	ne[idx] = h[a]
	h[a] = idx
	idx += 1

def dfs(u, father) :
	i = h[u]
	while ~ i : #枚举物品组
		ver = e[i]
		if ver != father :
			dfs(ver, u)
			for j in range(m, -1, -1) : #枚举体积
				for k in range(j) : #枚举物品组中的体积,枚举边数
					f[u][j] = max(f[u][j], f[u][j - k - 1] + f[ver][k] + w[i])
		i = ne[i]

n, m = map(int,input().split())

for i in range(n - 1) :
	a, b, c = map(int, input().split())
	add(a, b, c), add(b, a, c)

dfs(1, -1)
print(f[1][m])

树形dp + 状态机

没有上司的舞会

思路

状态机模型

0:不参加舞会

1:参加舞会

动态规划

状态表示

集合

f[u, 0]:以u做根节点不取u节点的树的最大快乐值

f[u, 1]:以u做根节点取u节点的树的最大快乐值

属性：max

状态计算：以u作根节点的最大快乐值

max(f[u, 0], f[u, 1])

f[u][0] += max

f[j][0],f[j][1],j为u的子节点

f[u][1] +=

f[j][0]

代码

import sys
N = 6010

sys.setrecursionlimit(N)
h = [-1] * N
e = [-1] * N
ne = [-1] * N
idx = 0
happy = [0] * N
has_fa = [False] * N
f = [[0, 0] for _ in range(N)]

def add(a, b) :
	global idx
	e[idx] = b
	ne[idx] = h[a]
	h[a] = idx
	idx += 1

def dfs(u) :
	f[u][1] = happy[u]

	i = h[u]
	while i != -1 :
		j = e[i]
		dfs(j)
		f[u][0] += max(f[j][0], f[j][1])
		f[u][1] += f[j][0]
		i = ne[i]

n = int(input())

for i in range(1, n + 1) :
	happy[i] = int(input())

for i in range(n - 1) :
	a, b = map(int, input().split())
	add(b, a)
	has_fa[a] = True
root = 1
while has_fa[root] :
	root += 1
dfs(root)

print(max(f[root][0], f[root][1]))

战略游戏

思路

状态机模型：

1:放士兵

0:不放士兵

状态表示：
集合：f[x, 0]表示从以x为根的子树中，一部分节点安排士兵，并且x节点不安排士兵的士兵数的集合
f[x, 1]表示从以x为根的子树中，一部分节点安排士兵，并且x节点安排士兵的士兵数的集合
属性：士兵数的最小值
状态计算：
f [ x , 1 ] = ∑ s ∈ S o n ( x ) m i n ( f [ s , 0 ] , f [ s , 1 ] ) + 1 f [ x , 0 ] = ∑ s ∈ S o n ( x ) f [ s , 1 ] f[x, 1] = \sum_{s \in Son(x)} min(f[s, 0], f[s, 1]) + 1\\f[x, 0] = \sum_{s \in Son(x)}f[s, 1]f[x,1]=s∈Son(x)∑​min(f[s,0],f[s,1])+1f[x,0]=s∈Son(x)∑​f[s,1]

代码

import sys
sys.setrecursionlimit(6000)
N = 1510
e = [0] * N
ne = [-1] * N

def add(a, b) :
    global idx
    e[idx] = b
    ne[idx] = h[a]
    h[a] = idx
    idx += 1
    
def dfs(u) :
	f[u][1] = 1
	i = h[u]
	while ~ i :
		j = e[i]
		dfs(j)
		f[u][0] += f[j][1]
		f[u][1] += min(f[j][1], f[j][0])
		i = ne[i]

while True :
    try :
        n = int(input())
    except : break
    h = [-1] * N
    st = [False] * N
    idx = 0
    f = [[0] * 2 for _ in range(N)]
    for _ in range(n) :
        cmd = input().split(':')
        u = int(cmd[0])
        for i in map(int, cmd[1].split(')')[1].split()) :
            add(u, i)
            st[i] = True
    root = 0
    for i in range(n) : 
        if not st[i] :
            root = i
            break
    dfs(root)
    print(min(f[root][0], f[root][1]))

皇宫看守

思路

父节点 放置 哨兵，所有子节点都 可放可不放 哨兵
父节点 不放 哨兵，但是他至少有一个 子节点 放置哨兵，观察住了他
父节点 不放 哨兵，但 父节点 的 父节点 放置哨兵观察，则 子节点 可放可不放 哨兵
状态机模型

• 被父节点观察 ,不被自己观察（0）
• 被子节点观察，不被自己观察（1）
• 被自己来观察 （2）

代码

import sys
sys.setrecursionlimit(1510)
N = 1510

st = [False] * N
h = [-1] * N
e = [0] * N
ne = [-1] * N
w = [0] * N
idx = 0
f = [[0, 0, 0] for _ in range(N)]

def add(a, b) :
    global idx
    e[idx] = b
    ne[idx] = h[a]
    h[a] = idx
    idx += 1

def dfs(u) :
	f[u][2] = w[u]
	i = h[u]
	while ~ i :
		j = e[i]
		dfs(j)
		#当前节点被父节点看管，并且不被自己看管，则子节点要么被自己看管要么被子节点的子节点看管
		f[u][0] += min(f[j][1], f[j][2])
		#当前节点被自己看管，则子节点可以自己看管也可以被父节点或子节点看管
		f[u][2] += min(f[j][0], f[j][1], f[j][2])
		i = ne[i]
	i = h[u]
	f[u][1] = int(1e9)
	while ~ i :
		j = e[i]
		'''当前节点被子节点看管，且不被自己看管
		枚举被哪个子节点看管，此时当前节点一定被自己看管
		,其余子节点情况是可以被自己看管也可以被子节点的子节点看管，即
		当前节点被父节点看管，并且不被自己看管,减去其中当前节点
		自己看管也可以被子节点的子节点看管的最小值的情况
		'''
		f[u][1] = min(f[u][1], f[j][2] + f[u][0] - min(f[j][1], f[j][2]))
		i = ne[i]

n = int(input())

for _ in range(n) :
    cmd = list(map(int, input().split()))
    ver = cmd[0]
    w[ver], son = cmd[1], cmd[3 : ]
    for i in son :
        add(ver, i)
        st[i] = True
        
root = 0
for i in range(1, n + 1) :
    if not st[i] :
        root = i
dfs(root)
print(min(f[root][1], f[root][2]))

总结

//                          _ooOoo_                               //
//                         o8888888o                              //
//                         88" . "88                              //
//                         (| ^_^ |)                              //
//                         O\  =  /O                              //
//                      ____/`---'\____                           //
//                    .'  \\|     |//  `.                         //
//                   /  \\|||  :  |||//  \                        //
//                  /  _||||| -:- |||||-  \                       //
//                  |   | \\\  -  /// |   |                       //
//                  | \_|  ''\---/''  |   |                       //
//                  \  .-\__  `-`  ___/-. /                       //
//                ___`. .'  /--.--\  `. . ___                     //
//              ."" '<  `.___\_<|>_/___.'  >'"".                  //
//            | | :  `- \`.;`\ _ /`;.`/ - ` : | |                 //
//            \  \ `-.   \_ __\ /__ _/   .-` /  /                 //
//      ========`-.____`-.___\_____/___.-`____.-'========         //
//                           `=---='                              //
//      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        //
//         佛祖保佑       永无BUG     永不修改                       //