Codeforces Round 656 (Div. 3) F. Removing Leaves

Problem Description

给出一棵 $n$ 个节点的无根树。你可以进行以下操作：

选择 $k$ 个共同父节点的叶子节点，将 $k$ 个节点和与父节点相连的边删去。

求最大操作次数。

Input

第一行输入一个整数 $t$ $(1\le t\le 2\times 10^4)$ ，表示测试组数。

接下来每组测试数据第一行输入两个整数 $n$ , $k$ $(2\le n\le 2\times 10^5,1\le k<n)$ ，表示节点个数和删除的节点限制个数。接下来 $n-1$ 行每行输入两个整数 $x_i,y_i$ $(1\le x_i,y_i\le n)$ ，表示 $x_i$ 和 $y_i$ 之间有一条边。

题目保证 $\sum n\le 2\times 10^5$ 。

Output

输出最大操作次数。

Solution

首先考虑到删 $k$ 个叶子节点的操作是从原树的叶子节点向内进行的，这是具有拓扑关系的。

那么我们可以去考虑每个节点，将其视作根节点即可以找出所以情况的答案，但是这样复杂度是 $O(n^2)$ ，此时我们便考虑通过换根 $dp$ 去转移根节点状态优化。

$d{p}_{u,0}$ 表示为 $u$ 是否为可删节点，如何为 $0$ 即为可删节点，如果不为 $0$ 则为不可删节点。

$d{p}_{u,1}$ 表示为 $u$ 的儿子节点中可删节点的个数。

$an{s}_u$ 表示 $u$ 为父节点的子树对答案的贡献。

第一遍 $dfs$ 时，我们任意找一个节点为根，得到各个点的状态，状态转移为：

$$\{\begin{array}{l}d{p}_{u,1}=\sum [d{p}_{v,0}==0],\\ an{s}_u=\lfloor d{p}_{u,1}/k\rfloor +\sum an{s}_v,\\ d{p}_{u,0}=[d{p}_{u,1}\%k\ne 0]+\sum d{p}_{v,0},\end{array}$$

然后第二遍 $dfs$ 时，首先要将 $u$ 状态更新为儿子节点， $an{s}_u-=an{s}_v$ ， $d{p}_{u,0}-=d{p}_{v,0}$ 。

然后考虑转移的节点 $v$ 是否为可删节点 ，如果是，考虑以下两种情况：

1. $d{p}_{u,1}\%k==0$ ，说明 $v$ 是对 $u$ 的答案有贡献的，且 $u$ 会变成不可删节点，我们需要令 $an{s}_u--$ , $d{p}_{u,0}++$。
2. $(d{p}_{u,0}-1)\%k==0$ ，说明在去掉这个节点后，$u$ 的可删节点将没有残余，可能成为不可删节点，所以要 $d{p}_{u,0}--$ 。

然后我们更新 $v$ 的状态，首先判断一下是否 $d{p}_{u,0}==0$ ，如果是则 $u$ 变成可删节点， $d{p}_{v,1}++$ 。之后类似第一遍的 $dfs$ 转移即可，不过要注意需要先减去旧状态对状态的影响，下面中 $b{e}_1$ 表示 $d{p}_{v,1}$ 为儿子节点时的状态：

$$\{\begin{array}{l}d{p}_{v,0}=d{p}_{v,0}+d{p}_{u,0}+[d{p}_{v,1}\%k\ne 0]-[b{e}_1\%k\ne 0],\\ an{s}_v=an{s}_v+an{s}_u+\lfloor d{p}_{v,1}/k\rfloor -\lfloor b{e}_1/k\rfloor ,\end{array}$$

然后遍历下一个节点统计最大值，之后记得回溯状态即可。

Code

#include <bits/stdc++.h>
#define endl '\n'
using namespace std;
constexpr int N = 2e5 + 10, M = 4e5 + 10;
int n, k;
int head[N], e[M], ne[M], idx;
inline void addedge(int a, int b) {
	e[idx] = b, ne[idx] = head[a], head[a] = idx++;
}
int res, ans[N];
array<int, 2>dp[N];
void initial_dfs(int u, int fa) {
	for (int i = head[u]; i != -1; i = ne[i]) {
		int v = e[i];
		if (v == fa)continue;
		initial_dfs(v, u);
		ans[u] += ans[v], dp[u][0] += dp[v][0];
		if (!dp[v][0])dp[u][1]++;//儿子节点为可删节点才对答案有贡献
	}
	if (dp[u][1] % k)dp[u][0]++;//如果该节点操作后有不可删节点时
	ans[u] += dp[u][1] / k;
}
void dfs(int u, int fa) {
	res = max(res, ans[u]);
	for (int i = head[u]; i != -1; i = ne[i]) {
		int v = e[i];
		if (v == fa)continue;
		auto a = ans[u], b = ans[v];
		auto l = dp[u], r = dp[v];
		ans[u] -= ans[v], dp[u][0] -= dp[v][0];
		if (!dp[v][0]) {//当转移节点是可删节点时
			if (dp[u][1] % k == 0) ans[u]--, dp[u][0]++;//如果v对u的答案是有贡献的
			if (--dp[u][1] % k == 0)dp[u][0]--;//如果v可能是限制u成为可删节点
		}
		if (!dp[u][0])dp[v][1]++;//如果u变成可删节点
		//将v的状态转移成根节点状态
		dp[v][0] += (dp[u][0] + (dp[v][1] % k != 0) - (r[1] % k != 0));
		ans[v] += (ans[u] + dp[v][1] / k - r[1] / k);
		dfs(v, u);
		ans[u] = a, ans[v] = b, dp[u] = l, dp[v] = r;//状态回溯
	}
}
void solve() {
	cin >> n >> k;
	res = idx = 0;
	for (int i = 0; i <= n; i++) {
		ans[i] = dp[i][0] = dp[i][1] = 0;
		head[i] = -1;
	}
	for (int i = 1; i <= n - 1; i++) {
		int a, b;
		cin >> a >> b;
		addedge(a, b), addedge(b, a);
	}
	initial_dfs(1, 0);
	dfs(1, 0);
	cout << res << endl;
}
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int t;
	cin >> t;
	while (t--)solve();
}