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;
}