P3523 [POI2011] DYN-Dynamite （二分+树上贪心）

P3523 [POI2011] DYN-Dynamite

二分+树上贪心

首先这题可以二分 $K$ ，转化为判定性问题：是否存在 $m$ 个点使得所有关键节点的 $d i s \leq K$ 。

那么意思就是，每个点可以控制 $K$ 距离以内的关键点。那么我们可以从叶子节点向上贪心，实在覆盖不到了再选点。

那么我们要判断该点是否要选，考虑维护 $f_{u}$ 和 $g_{u}$ 分别表示被选的点中到 $u$ 节点的最短距离和还没被覆盖的关键点中到 $u$ 节点的最远距离。

假设当前在 $u$ 节点，需要判断三种情况：

$u$ 为关键点并且 $f_{u} > K$ ，也就是 $u$ 目前无法被覆盖，那么更新 $g_{u} = max (g_{u}, 0)$ 。
$f_{u} + g_{u} \leq K$ ，首先明确这样的两条路径是不会出现重叠的，因为如果重叠，那么我们一定在两点的 $l c a$ 处已经计算了一次。那么 $u$ 子树所有关键点都被覆盖，更新 $g_{u} = - i n f$ 。
$g_{u} = K$ ， $u$ 必须被选，更新 $f_{u}$ 和 $g_{u}$ 。

复杂度 $O (n \log n)$ 。

#include <bits/stdc++.h>
#define pii std::pair<int, int>
#define fi first
#define se second
#define pb push_back

typedef long long i64;
const i64 iinf = 0x3f3f3f3f, linf = 0x3f3f3f3f3f3f3f3f;
const int N = 3e5 + 10;
int n, m, ans, ret, now;
int a[N], f[N], g[N];
std::vector<int> e[N];
void dfs(int u, int fa) {
	f[u] = iinf, g[u] = -iinf;
	for(auto v : e[u]) {
		if(v == fa) continue;
		dfs(v, u);
		f[u] = std::min(f[u], f[v] + 1);
		g[u] = std::max(g[u], g[v] + 1);
	}
	if(a[u] && f[u] > now) g[u] = std::max(g[u], 0);
	if(f[u] + g[u] <= now) g[u] = -iinf;
	if(g[u] == now) {
		ret++, f[u] = 0, g[u] = -iinf;
	}
}
bool check(int x) {
	ret = 0, now = x;
	dfs(1, 0);
	ret += (g[1] >= 0);
	return ret <= m;
}
void Solve() {
	std::cin >> n >> m;
	for(int i = 1; i <= n; i++) std::cin >> a[i];

	for(int i = 1; i < n; i++) {
		int u, v;
		std::cin >> u >> v;
		e[u].pb(v), e[v].pb(u);
	}
	int l = 0, r = n;
	while(l <= r) {
		int mid = (l + r) >> 1;
		if(check(mid)) ans = mid, r = mid - 1;
		else l = mid + 1;
	}
	std::cout << ans << "\n";
}
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
	Solve();

	return 0;
}