P3523 [POI2011] DYN-Dynamite

P3523 [POI2011] DYN-Dynamite

二分+树上贪心

首先这题可以二分 \(K\)，转化为判定性问题：是否存在 \(m\) 个点使得所有关键节点的 \(dis\le K\)。

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

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

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

1. \(u\) 为关键点并且 \(f_u>K\)，也就是 \(u\) 目前无法被覆盖，那么更新 \(g_u=\max(g_u,0)\)。
2. \(f_u+g_u\le K\)，首先明确这样的两条路径是不会出现重叠的，因为如果重叠，那么我们一定在两点的 \(lca\) 处已经计算了一次。那么 \(u\) 子树所有关键点都被覆盖，更新 \(g_u=-inf\)。
3. \(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;
}