算法刷题day39：树形DP

引言

今天写了个树形DP，就是在树上的DP，其实每道题的总体是一样的，从代码上都能看出来，其实写多了感觉就是背之前写过的代码，其实也就是别人写过的代码，这种题基本就是这，死记硬背肯定是不行的，主要是理解大概的思路，然后再现场调，继续加油吧！

---

一、病毒溯源

标签：树形DP、求方案

思路：就是给了一棵树，问这棵树的直径，并且求出直径最长的方案所对应的值。这道题用树形DP做就可以了，基本思路就是先递归出各个儿子的值，然后每个儿子进行比较，找最大的并且字典序较小的，然后存起来就行了。具体细节见代码。

题目描述：

病毒容易发生变异。

某种病毒可以通过突变产生若干变异的毒株，而这些变异的病毒又可能被诱发突变产生第二代变异，如此继续不断变化。

现给定一些病毒之间的变异关系，要求你找出其中最长的一条变异链。

在此假设给出的变异都是由突变引起的，不考虑复杂的基因重组变异问题 —— 即每一种病毒都是由唯一的一种病毒突变而来，并且
不存在循环变异的情况。

输入格式
输入在第一行中给出一个正整数 N，即病毒种类的总数。于是我们将所有病毒从 0 到 N−1 进行编号。

随后 N 行，每行按以下格式描述一种病毒的变异情况：

k 变异株1 …… 变异株k

其中 k 是该病毒产生的变异毒株的种类数，后面跟着每种变异株的编号。第 i 行对应编号为 i 的病毒（0≤i<N）。题目保证病毒源
头有且仅有一个。

输出格式
首先输出从源头开始最长变异链的长度。

在第二行中输出从源头开始最长的一条变异链，编号间以 1 个空格分隔，行首尾不得有多余空格。如果最长链不唯一，则输出最小序列。

注：我们称序列 {a1,…,an} 比序列 {b1,…,bn} “小”，如果存在 1≤k≤n 满足 ai=bi 对所有 i<k 成立，且 ak<bk。

数据范围
1≤N≤104
输入样例：
10
3 6 4 8
0
0
0
2 5 9
0
1 7
1 2
0
2 3 1
输出样例：
4
0 4 9 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1e4+10, M = N;

int n;
int h[N], e[N], ne[N], idx;
int f[N];
bool has_father[N];
int path[N];

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void dfs(int u)
{
	f[u] = 1;
	path[u] = -1;
	
	int maxid = -1;
	for(int i = h[u]; i != -1; i = ne[i])
	{
		int j = e[i];
		dfs(j);
		
		if(maxid == -1 || f[j] > f[maxid] || f[j] == f[maxid] && j < maxid) maxid = j;
	}
	
	f[u] += f[maxid];
	path[u] = maxid;
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	memset(h, -1, sizeof h);
	cin >> n;
	for(int i = 0; i < n; ++i)
	{
		int k; cin >> k;
		while(k--)
		{
			int b; cin >> b;
			add(i,b);
			has_father[b] = true;
		}
	}
	
	int root = 0;  // 没说明根结点是哪个
	while(has_father[root]) root++;
	
	dfs(root);
	
	cout << f[root] << endl;
	cout << root;
	for(int i = path[root]; i != -1; i = path[i])
	{
		cout << " " << i;
	}
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

---

二、没有上司的舞会

标签：动态规划、树形DP

思路：定义一个 $f[u][2]$ ，其中 $0$ 代表不选该结点， $1$ 则代表选该节点，则我们可以从根结点递归出每个儿子的值，由此可以推出方程： $$f[u][0]=\sum max(f[j][0],f[j][1])$$ $$f[u][1]=\sum f[j][0]$$ 然后就根据方程得出答案即可，这题跟上一个题的大体是一样的。

题目描述：

Ural 大学有 N 名职员，编号为 1∼N。

他们的关系就像一棵以校长为根的树，父节点就是子节点的直接上司。

每个职员有一个快乐指数，用整数 Hi 给出，其中 1≤i≤N。

现在要召开一场周年庆宴会，不过，没有职员愿意和直接上司一起参会。

在满足这个条件的前提下，主办方希望邀请一部分职员参会，使得所有参会职员的快乐指数总和最大，求这个最大值。

输入格式
第一行一个整数 N。

接下来 N 行，第 i 行表示 i 号职员的快乐指数 Hi。

接下来 N−1 行，每行输入一对整数 L,K，表示 K 是 L 的直接上司。（注意一下，后一个数是前一个数的父节点，不要搞反）。

输出格式
输出最大的快乐指数。

数据范围
1≤N≤6000,−128≤Hi≤127
输入样例：
7
1
1
1
1
1
1
1
1 3
2 3
6 4
7 4
4 5
3 5
输出样例：
5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 6010, M = N;

int n;
int w[N];
int h[N], e[M], ne[M], idx;
int f[N][2];  // f[u][0]代表该结点不选  1代表选 
bool has_father[N];

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++; 
}

void dfs(int u)
{
	f[u][1] = w[u];
	
	for(int i = h[u]; i != -1; i = ne[i])
	{
		int j = e[i];
		dfs(j);
		
		f[u][0] += max(f[j][0], f[j][1]);
		f[u][1] += f[j][0];
	}
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	memset(h, -1, sizeof h);
	cin >> n;
	for(int i = 1; i <= n; ++i) cin >> w[i];
	for(int i = 0; i < n - 1; ++i)
	{
		int a, b; cin >> a >> b;
		add(b,a);
		has_father[a] = true;
	}
	
	int root = 1;
	while(has_father[root]) root++;
	
	dfs(root);
	
	cout << max(f[root][0], f[root][1]) << endl;
	
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

---

三、生命之树

标签：树形DP

思路：题意就是找到最大的连通块，我们可以定义一个 $f[u]$ 代表包含 $u$ 的最大连通块数量，思路跟 树的重心 这道题基本一样，遍历没访问过的儿子的值跟 $0$ 比较，肯定是越大越好。因为是一个递归过程，访问过的要等没访问过的才能算值，并且如果存在向回递归的结点比当前的大，那么最大的值就是以另一个结点为根的值了，所以要用判重一下。

题目描述：

在X森林里，上帝创建了生命之树。

他给每棵树的每个节点（叶子也称为一个节点）上，都标了一个整数，代表这个点的和谐值。

上帝要在这棵树内选出一个非空节点集 S，使得对于 S 中的任意两个点 a,b，都存在一个点列 {a,v1,v2,…,vk,b} 使得这个点列中
的每个点都是 S 里面的元素，且序列中相邻两个点间有一条边相连。

在这个前提下，上帝要使得 S 中的点所对应的整数的和尽量大。

这个最大的和就是上帝给生命之树的评分。

经过 atm 的努力，他已经知道了上帝给每棵树上每个节点上的整数。

但是由于 atm 不擅长计算，他不知道怎样有效的求评分。

他需要你为他写一个程序来计算一棵树的分数。

输入格式
第一行一个整数 n 表示这棵树有 n 个节点。

第二行 n 个整数，依次表示每个节点的评分。

接下来 n−1 行，每行 2 个整数 u,v，表示存在一条 u 到 v 的边。

由于这是一棵树，所以是不存在环的。

树的节点编号从 1 到 n。

输出格式
输出一行一个数，表示上帝给这棵树的分数。

数据范围
1≤n≤105,每个节点的评分的绝对值均不超过 106。

输入样例：
5
1 -2 -3 4 5
4 2
3 1
1 2
2 5
输出样例：
8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1e5+10, M = N * 2;

int n;
int w[N];
int h[N], e[M], ne[M], idx;
LL f[N];

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void dfs(int u, int father) // 找包含u的最大连通块 
{
	f[u] = w[u];
	
	for(int i = h[u]; i != -1; i = ne[i])
	{
		int j = e[i];
		if(j == father) continue;
		
		dfs(j,u);
		f[u] += max(0ll, f[j]);
	}
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	memset(h, -1, sizeof h);
	cin >> n;
	for(int i = 1; i <= n; ++i) cin >> w[i];
	for(int i = 0; i < n - 1; ++i)
	{
		int a, b; cin >> a >> b;
		add(a,b), add(b,a);
	}
	
	dfs(1,-1);
	
	LL res = f[1];
	for(int i = 2; i <= n; ++i) res = max(res, f[i]);
	cout << res << endl;
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

---

四、树的重心

标签：树形DP

思路：我发现这种树形 $DP$ 都是从根向下递归，并且都不会向回走，算是一种思维定式吧，具体解释上一题已经说了。这题就是找删除当前结点所剩的连通块的最大值最小，递归找每个结点的连通块点数，然后找最大的那个连通块，向根方向的连通块用总数把所有当前结点的连通块数一减就是了，然后找其中最大的，然后定义一个全局变量，找其中最小的。

题目描述：

给定一颗树，树中包含 n 个结点（编号 1∼n）和 n−1 条无向边。

请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。

重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。

输入格式
第一行包含整数 n，表示树的结点数。

接下来 n−1 行，每行包含两个整数 a 和 b，表示点 a 和点 b 之间存在一条边。

输出格式
输出一个整数 m，表示将重心删除后，剩余各个连通块中点数的最大值。

数据范围
1≤n≤105
输入样例
9
1 2
1 7
1 4
2 8
2 5
4 3
3 9
4 6
输出样例：
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1e5+10, M = N * 2;

int n;
int h[N], e[M], ne[M], idx;
int ans = 2e9;
bool st[N];

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

int dfs(int u)  // 找包含u的连通块点数 
{
	st[u] = true;
	
	int size = 0, sum = 1;
	for(int i = h[u]; i != -1; i = ne[i])
	{
		int j = e[i];
		if(st[j]) continue;
		
		int t = dfs(j);
		sum += t;
		size = max(size, t);
	}
	
	size = max(size, n - sum);
	ans = min(ans, size);
	return sum;
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	memset(h, -1, sizeof h);
	cin >> n;
	for(int i = 0; i < n - 1; ++i)
	{
		int a, b; cin >> a >> b;
		add(a,b), add(b,a);
	}
	
	dfs(1);
	
	cout << ans << endl; 
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59