CF1795F Blocking Chips 题解

可以发现，答案一定是可二分的。

那么我们思考如何判定。首先，对于一个点，在一棵 DFS 树上，它只有两种走法。要么往下走，要么走到祖先的某个点，然后考虑能否往下。

于是我们可以设计一个 DP，$f_u$ 表示 $u$ 点能往下的最大长度。$f_u = \max \limits_{c_j = 0}\{f_j+1\}$。$c_j$ 表示 $j$ 能否走，$c_j =0$ 表示能走。

对于一个点，先处理 $f_u$，如果 $f_u \geq need_u$，那么直接往下走，不影响上面的显然最优。

否则，$c_{fa}=1$，并且将 $need_{fa}$ 更改。如果发现 $fa$ 本身就不能走直接退出。

我们从下往上处理，所以对于每个点，肯定优先往下走最好。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
using namespace std;

const int N = 2e5 + 5;

int t, n, k, a[N];
vector<int> G[N];

int need[N], can[N], f[N];
bool col[N];
bool flag = 1;

void dfs(int u, int fa)
{
	for (auto& j : G[u])
	{
		if (j != fa)
		{
			dfs(j, u);
			if (!col[j]) f[u] = max(f[u], f[j] + 1);
		}
	}
	if (col[u])
	{
		if (f[u] < need[u])
		{
			if (col[fa] || fa == 0)
			{
				flag = 0;
				return;
			}
			col[fa] = 1;
			need[fa] = need[u] - 1;
		}
		f[u] = 0;
	}
}

bool check(int x)
{
	flag = 1;
	for (int i = 1; i <= n; i++) need[i] = 0, f[i] = 0, col[i] = 0;
	for (int i = 1; i <= k; i++) col[a[i]] = 1;
	for (int i = 1; i <= k; i++)
	{
		need[a[i]] = x / k + (x % k >= i);
	}
	dfs(1, 0);
	return flag;
}

int main()
{
	scanf("%d", &t);
	while (t--)
	{
		scanf("%d", &n);
		for (int i = 1; i <= n; i++) G[i].clear(), G[i].shrink_to_fit(), col[i] = need[i] = f[i] = 0;
		for (int i = 1; i < n; i++)
		{
			int u, v;
			scanf("%d%d", &u, &v);
			G[u].emplace_back(v);
			G[v].emplace_back(u);
		}
		scanf("%d", &k);
		for (int i = 1; i <= k; i++)
		{
			scanf("%d", &a[i]);
			col[a[i]] = 1;
		}
		int l = 0, r = n, ans = 0;
		while (l <= r)
		{
			int mid = l + r >> 1;
			if (check(mid))
			{
				l = mid + 1;
				ans = mid;
			}
			else
			{
				r = mid - 1;
			}
		}
		printf("%d\n", ans);
	}
	return 0;
}