DP专题-专项训练：树形 DP

目录

• 1. 前言
• 2. 练习题
  • P2585 [ZJOI2006]三色二叉树
  • P4516 [JSOI2018]潜入行动
  • P2607 [ZJOI2008]骑士
• 3. 总结

1. 前言

本篇博文是树形 DP 的练习题。

没有学过树形 DP？

传送门：DP专题-学习笔记：树形 DP

树形 DP 的题目一般是比较容易看出来的 （树难道还看不出来吗），其唯一难点在转移方程上。

2. 练习题

题单：

• P2585 [ZJOI2006]三色二叉树
• P4516 [JSOI2018]潜入行动
• P2607 [ZJOI2008]骑士

P2585 [ZJOI2006]三色二叉树

这道题首先需要建棵树，可以参照代码。

这棵树是棵二叉树。

二叉树！这样为我们的转移带来了极大的方便。

设 \(f[i][1/2/3][0/1]\) 表示当前节点涂 红色/绿色/蓝色 ，总共涂绿色次数的 最小/最大值。记 \(l(p)\) 是 \(p\) 的左儿子，\(r(p)\) 是 \(p\) 的右儿子。

那么：

1. 只有左儿子，没有右儿子。
   遵循相邻点不能相同涂色的原则转移即可。
2. 只有右儿子，没有左儿子。
   同上。
3. 既有左儿子，也有右儿子。
   这个时候需要注意的是两个儿子涂色也不能相同。

代码：

#include <bits/stdc++.h>
#define Min(a, b) ((a < b) ? a : b)
#define Max(a, b) ((a > b) ? a : b)
using namespace std;

typedef long long LL;
const int MAXN = 5e5 + 10;
int f[MAXN][3][2], cnt;
//1 = red, 2 = green(goal), 3 = blue
//0 = min, 1 = max
struct node
{
	int l, r;
	#define l(p) tree[p].l
	#define r(p) tree[p].r
}tree[MAXN];

int read()
{
	int sum = 0, fh = 1; char ch = getchar();
	for (; ch < '0' || ch > '9'; ch = getchar()) fh -= (ch == '-') << 1;
	for (; ch >= '0' && ch <= '9'; ch = getchar()) sum = (sum << 3) + (sum << 1) + (ch ^ 48);
	return (fh == 1) ? sum : -sum;
}

int build()
{
	int now = ++cnt; int t;
	scanf("%1d", &t);
	if (t == 1) l(now) = build();
	if (t == 2) {l(now) = build(); r(now) = build();}
	return now;
}
//0 = min, 1 = max
void dfs(int now)
{
	f[now][2][0] = f[now][2][1] = 1;
	if (l(now)) dfs(l(now));
	if (r(now)) dfs(r(now));
	if (l(now) && !r(now))
	{
		f[now][1][0] += Min(f[l(now)][2][0], f[l(now)][3][0]);
		f[now][2][0] += Min(f[l(now)][1][0], f[l(now)][3][0]);
		f[now][3][0] += Min(f[l(now)][1][0], f[l(now)][2][0]);
		f[now][1][1] += Max(f[l(now)][2][1], f[l(now)][3][1]);
		f[now][2][1] += Max(f[l(now)][1][1], f[l(now)][3][1]);
		f[now][3][1] += Max(f[l(now)][1][1], f[l(now)][2][1]);
	}
	else if (r(now) && !l(now))
	{
		f[now][1][0] += Min(f[r(now)][2][0], f[r(now)][3][0]);
		f[now][2][0] += Min(f[r(now)][1][0], f[r(now)][3][0]);
		f[now][3][0] += Min(f[r(now)][1][0], f[r(now)][2][0]);
		f[now][1][1] += Max(f[r(now)][2][1], f[r(now)][3][1]);
		f[now][2][1] += Max(f[r(now)][1][1], f[r(now)][3][1]);
		f[now][3][1] += Max(f[r(now)][1][1], f[r(now)][2][1]);
	}
	else if (l(now) && r(now))
	{
		f[now][1][0] += Min(f[l(now)][2][0] + f[r(now)][3][0], f[l(now)][3][0] + f[r(now)][2][0]);
		f[now][2][0] += Min(f[l(now)][1][0] + f[r(now)][3][0], f[l(now)][3][0] + f[r(now)][1][0]);
		f[now][3][0] += Min(f[l(now)][1][0] + f[r(now)][2][0], f[l(now)][2][0] + f[r(now)][1][0]);
		f[now][1][1] += Max(f[l(now)][2][1] + f[r(now)][3][1], f[l(now)][3][1] + f[r(now)][2][1]);
		f[now][2][1] += Max(f[l(now)][1][1] + f[r(now)][3][1], f[l(now)][3][1] + f[r(now)][1][1]);
		f[now][3][1] += Max(f[l(now)][1][1] + f[r(now)][2][1], f[l(now)][2][1] + f[r(now)][1][1]);
	}
}

int main()
{
	build();
	dfs(1);
	printf("%d %d\n", Max(f[1][1][1], Max(f[1][2][1], f[1][3][1])), Min(f[1][1][0], Min(f[1][2][0], f[1][3][0])));
	return 0;
}

P4516 [JSOI2018]潜入行动

这篇题解同步在我的 这篇博文 上。

特别提醒：本题卡空间。如果您的代码 MLE 了而且思路没有问题，请直接前往『关于卡空间』这一部分。

P.S. WA+MLE 不计入上述范围内。

思路讲解：

本题是一道树上统计类 DP。

前置知识：树形 DP。

对于这道题，首先设下两维状态 \(f[u][i]\)，\(u\) 为节点编号，\(i\) 表示用了几个监听设备。

但是状态不够啊，我们不知道是否被监听，儿子节点是否被监听等等。

于是，我们新增两维 \(0/1\) 状态来表示。

那么这道题的状态如下：

设 \(f[u][i][0/1][0/1]\) 表示当前节点为 \(u\) ，子树中已经遍历的所有节点 上放置 \(i\) 个监听装备的方案数，而且所有儿子节点均被监听，其中第三维状态表示 \(u\) 节点是否放下监听设备，第四维状态表示 \(u\) 节点是否被 儿子节点 监听。

分情况讨论。以下均设 1 号节点为根节点， \(now\) 为当前节点，\(u\) 为儿子节点，\(i\) 是 \(now\) 子树中已经遍历的所有节点上放置的监听装备数，\(j\) 是 \(u\) 子树上放置的监听装备数，\(V\) 为所有 \(u\) 构成的集合。这里采用刷表法转移，目标为 \(f[now][i+j][0/1][0/1]\)。

1. \(f[now][i+j][0][0]\)

这个时候需要保证 \(u\) 被监听，但是 \(u\) 上面不能放监听装备，有转移方程：

\[f[now][i+j][0][0]=f[now][i][0][0] \times \sum_{u \in V}f[u][j][0][1] \]

2. \(f[now][i+j][0][1]\)

此时 \(now\) 被监听了，但是需要考虑是谁监听的：

2. 1. 可以是 \(u\) 来监听，此时 \(now\) 之前不能被监听，然而 \(u\) 要被监听，于是这一部分贡献：$$f[now][i][0][0] \times \sum_{u \in V}f[u][j][1][1]$$
   2. 可以是别的节点来监听，此时 \(u\) 放不放无所谓，然而 \(u\) 要被监听，于是这一部分贡献：$$f[now][i][0][1] \times \sum_{u \in V}(f[u][j][0][1]+f[u][j][1][1])$$

综上，有转移方程：

\[f[now][i+j][0][1] = f[now][i][0][0] \times \sum_{u \in V}f[u][j][1][1] + f[now][i][0][1] \times \sum_{u \in V}(f[u][j][0][1]+f[u][j][1][1]) \]

3. \(f[now][i+j][1][0]\)

此时 \(u\) 是否被监听无所谓，但是不能放装置，有转移方程：

\[f[now][i+j][1][0]=f[now][i][1][0] \times \sum_{u \in V}(f[u][j][0][0] + f[u][j][0][1]) \]

4. \(f[now][i+j][1][1]\)

此时仍然要根据 \(now\) 是否被监听来分类讨论：

4. 1. 由 \(u\) 来监听，但是因为 \(now\) 放了装置，所以 \(u\) 是否被监听无所谓，这一部分贡献为：$$f[now][i][1][0] \times \sum_{u \in V}(f[u][j][1][0] + f[u][j][1][1])$$
   2. 不由 \(u\) 来监听，此时 \(u\) 放不放无所谓，是否被监听也无所谓，这一部分贡献为：$$f[now][i][1][1] \times \sum_{u \in V}(f[u][j][0][0] + f[u][j][0][1] + f[u][j][1][0] + f[u][j][1][1])$$

综上，有转移方程：

\[f[now][i+j][1][1]=f[now][i][1][0] \times \sum_{u \in V}(f[u][j][1][0] + f[u][j][1][1])+f[now][i][1][1] \times \sum_{u \in V}(f[u][j][0][0] + f[u][j][0][1] + f[u][j][1][0] + f[u][j][1][1]) \]

式子不是很长（确信

那么综合一下上面的四个方程：

\[f[now][i+j][0][0]=f[now][i][0][0] \times \sum_{u \in V}f[u][j][0][1] \]

\[f[now][i+j][0][1] = f[now][i][0][0] \times \sum_{u \in V}f[u][j][1][1] + f[now][i][0][1] \times \sum_{u \in V}(f[u][j][0][1]+f[u][j][1][1]) \]

\[f[now][i+j][1][0]=f[now][i][1][0] \times \sum_{u \in V}(f[u][j][0][0] + f[u][j][0][1]) \]

\[f[now][i+j][1][1]=f[now][i][1][0] \times \sum_{u \in V}(f[u][j][1][0] + f[u][j][1][1])+f[now][i][1][1] \times \sum_{u \in V}(f[u][j][0][0] + f[u][j][0][1] + f[u][j][1][0] + f[u][j][1][1]) \]

初始状态为对于任意点 \(now\)，\(f[now][0][0][0]=f[now][1][1][0]\)。

最后答案是 \(f[1][k][0][1]+f[1][k][1][1]\)。

所有过程注意随时取模。

一些注意点：

1. 随时取模。
2. 转移的时候需要注意对于当前节点 \(now\)，我们需要临时数组 \(tmp[i][0/1][0/1]\) 来存下当前节点的状态，防止因为修改而导致的 WA。具体可以参考我的代码。
3. 记得记录子树的大小，因为可能存在 \(size_{now}<k\) 的情况，此时我们至多只能放 \(size_{now}\) 个。

关于卡空间

这道题很毒瘤，我一开始开 long long 被卡空间了，最后看的题解才知道为什么会 MLE。

这道题需要注意：

1. 所有变量全部开 int 类型，尤其是 f 和 tmp 数组。
2. 运算的时候需要强制转换类型，同时取模。

代码：

#include <bits/stdc++.h>
#define Min(a, b) ((a < b) ? a : b)
using namespace std;

typedef long long LL;
const int MAXN = 1e5 + 10, P = 1e9 + 7, MAXK = 100 + 10;
int n, k, f[MAXN][MAXK][2][2], tmp[MAXK][2][2], size[MAXN];
vector <int> Next[MAXN];

int read()
{
	int sum = 0, fh = 1; char ch = getchar();
	for (; ch < '0' || ch > '9'; ch = getchar()) fh -= (ch == '-') << 1;
	for (; ch >= '0' && ch <= '9'; ch = getchar()) sum = (sum << 3) + (sum << 1) + (ch ^ 48);
	return (fh == 1) ? sum : -sum;
}

void dfs(int now, int fa)
{
	size[now] = f[now][0][0][0] = f[now][1][1][0] = 1;
	for (int v = 0; v < Next[now].size(); ++v)
	{
		int u = Next[now][v];
		if (u == fa) continue;
		dfs(u, now);
		for (int i = 0; i <= k; ++i)
		{
			tmp[i][0][0] = f[now][i][0][0]; f[now][i][0][0] = 0;
			tmp[i][0][1] = f[now][i][0][1]; f[now][i][0][1] = 0;
			tmp[i][1][0] = f[now][i][1][0]; f[now][i][1][0] = 0;
			tmp[i][1][1] = f[now][i][1][1]; f[now][i][1][1] = 0;
		}
		for (int i = 0; i <= Min(size[now], k); ++i)
			for (int j = 0; j <= Min(size[u], k - i); ++j)
			{
				f[now][i + j][0][0] = ((LL)f[now][i + j][0][0] + (LL)tmp[i][0][0] * f[u][j][0][1]) % P;
				f[now][i + j][0][1] = ((LL)f[now][i + j][0][1] + (LL)tmp[i][0][0] * f[u][j][1][1] % P + (LL)tmp[i][0][1] * ((LL)f[u][j][0][1] + f[u][j][1][1]) % P) % P;
				f[now][i + j][1][0] = ((LL)f[now][i + j][1][0] + (LL)tmp[i][1][0] * ((LL)f[u][j][0][1] + f[u][j][0][0]) % P) % P;
				f[now][i + j][1][1] = ((LL)f[now][i + j][1][1] + (LL)tmp[i][1][0] * ((LL)f[u][j][1][0] + f[u][j][1][1]) % P + (LL)tmp[i][1][1] * ((LL)f[u][j][0][0] + f[u][j][0][1] + f[u][j][1][0] + f[u][j][1][1]) % P) % P;
			}
		size[now] += size[u];
	}
}

int main()
{
	n = read(), k = read();
	for (int i = 1; i < n; ++i)
	{
		int x = read(), y = read();
		Next[x].push_back(y); Next[y].push_back(x);
	}
	dfs(1, 1);
	printf("%d\n", ((LL)f[1][k][0][1] + f[1][k][1][1]) % P);
	return 0;
}

P2607 [ZJOI2008]骑士

这道题乍一看，以为就是没有上司的舞会这道题，结果……WA 了。

然后我又重新读了读题，同时看了看难度和题解，发现不对：这张图是基环树森林。

基环树是什么？

基环树就是一棵树，多了一条边，构成了这棵树上唯一的环。

比如下面就是一棵基环树。

那么基环树森林呢？就是由多棵基环树构成的森林。

对于基环树，有两种处理办法：

1. 将环找出来，这样就变成了一个环挂着一些子树的问题，所有子树信息合并到环上处理。
2. 将环找出来，然后随意断掉其中一条边，这样就是一棵树。

那么回到这道题。

接下来只考虑单棵基环树。

因为存在环，所以我们不能简单的存储图。

可以发现，如果我们将骑士厌恶的对象作为他的父亲连一条有向边 （也就是讨厌的人是自己的爸爸），那么这棵基环树上的环肯定是首位相连，而且其余子树上叶子节点出度为 0。

于是我们要做的事情是这样的：

首先找到环，从环上随意取一个节点作为根，临时 断掉其与其父亲的连边，做一遍 DP。方程跟没有上司的舞会一样，唯一需要注意的是根节点的真实父亲的 \(f[i][1]\) 设为负无穷，防止对答案造成干扰。

一遍 DP 做完后，我们取其父亲，同样做一遍 DP，结合两次答案得到最终结果。

但是为什么这样做就是对的呢？

首先，子树内的信息与环无关，无论是哪个根节点子树信息都相同，于是可以不考虑子树。

然后，考虑到任意节点可以与其相邻节点结合且该方案可能为最优解，那么在做完第一遍 DP 后被选中的根节点的父亲与指向它的点处理过答案，那么只需要再来一遍处理父亲与根节点的答案即可。

代码：

#include <bits/stdc++.h>
#define Max(a, b) ((a > b) ? a : b)
using namespace std;

typedef long long LL;
const int MAXN = 1e6 + 10;
int n, a[MAXN], fa[MAXN];
LL f[MAXN][2];
bool vis[MAXN];
vector <int> Next[MAXN];

int read()
{
	int sum = 0, fh = 1; char ch = getchar();
	for (; ch < '0' || ch > '9'; ch = getchar()) fh -= (ch == '-') << 1;
	for (; ch >= '0' && ch <= '9'; ch = getchar()) sum = (sum << 3) + (sum << 1) + (ch ^ 48);
	return (fh == 1) ? sum : -sum;
}

void dfs(int now, int fa, int root)
{
	vis[now] = 1;
	f[now][0] = 0, f[now][1] = a[now];
	for (int i = 0; i < Next[now].size(); ++i)
	{
		int u = Next[now][i];
		if (u == fa) continue;
		if (u == root) {f[now][1] = -0x3f3f3f3f3f3f3f3f; continue;}
		dfs(u, now, root);
		f[now][0] += Max(f[u][0], f[u][1]);
		f[now][1] += f[u][0];
	}
}

LL DP(int k)
{
	vis[k] = 1;
	int root = k;
	while (!vis[fa[root]]) {root = fa[root]; vis[root] = 1;}
	dfs(root, root, root);
	LL ans = 0;
	ans = Max(ans, Max(f[root][0], f[root][1]));
	root = fa[root]; vis[root] = 1;
	dfs(root, root, root);
	ans = Max(ans, Max(f[root][0], f[root][1]));
	return ans;
}

int main()
{
	n = read();
	for (int i = 1; i <= n; ++i)
	{
		a[i] = read(); fa[i] = read();
		Next[fa[i]].push_back(i);
	}
	LL sum = 0;
	for (int i = 1; i <= n; ++i)
		if (!vis[i]) sum += DP(i);
	printf("%lld\n", sum);
	return 0;
}

3. 总结

树形 DP 变化多端，虽然也很板子，但是思维难度还是很大的，需要多加练习。