[NOIP2015 提高组] 运输计划 题解

[NOIP2015 提高组] 运输计划 题解

注：本题解展现了较为完整的思路，若需查阅简要思路，可直接根据二级标题直接跳往「简要题解」部分。

题目描述

L 国有 $n$ 个星球，还有 $n-1$ 条双向航道，每条航道建立在两个星球之间，这 $n-1$ 条航道连通了 L 国的所有星球。对于每一条从 $x_i$ 通往 $y_i$ 的通道，飞船都需要 $t_i$ 的时间通过它，并且任意两艘飞船之间不会产生任何干扰。

现有 $m$ 个运输计划，每个运输计划形如：有一艘物流飞船需要从 $u_i$ 号星球沿最快的宇航路径飞行到 $v_i$ 号星球去。

小 P 可以把某一条航道改造成虫洞，飞船驶过虫洞不消耗时间， 试求出小 P 的物流公司完成阶段性工作所需要的最短时间是多少？

解法分析

可以发现航道和星球构成了一棵树，所以任意两点之间的路径是固定不变的。如果将树视为一个有根树，并记 $d_i$ 表示从 $i$ 号点到根节点的路径长度，记 $lca(u,v)$ 表示 $u$ 和 $v$ 两点的最近公共祖先，则 $s_i$ 到 $t_i$ 的路径长度可以表示为 $d_{s_i}+d_{t_i}-2\cdot d_{lca\left(s_i,t_i\right)}$.

首先发现，虫洞必须建在消耗时间最长的航道上，否则那条航道的时间不会缩短，答案也就不会变小。于是考虑枚举将航道上的哪一条边改为虫洞，那就需要快速求出改为虫洞之后剩下航道的所需最长时间。设最长的航道所需时间为 $maxt$，被改为虫洞的航道所需时间为 $t_0$，那么：

• 对于有虫洞的航道，其建造后的时间会减少 $t_0$，而原来这条航道所需时间就小于等于 $maxt$，所以建造后的时间小于等于 $maxt-t_0$
• 对于没有虫洞的航道，其时间不变。如果最长的航道建造了虫洞之后所需时间小于这条航道，那么这条航道就变成了“消耗时间最长的航道”

所以剩下航道的所需最长时间比较难求，无法快速求得时间，其原因是不能快速的知道有哪些航道覆盖了虫洞。

相反，如果我们知道了航道所需最长时间，再去看是否可以用一个虫洞达到这个时间，那么题目就会简单得多。

当我们知道了航道所需最长时间时，设其为 $t$，我们只需要找到一个虫洞使得所有航道的所需时间都小于等于 $t$。

修改之前所需时间小于等于 $t$ 的航道就不需要虫洞了，但是大于 $t$ 的每一条航道都需要虫洞，因此虫洞必须建造在这些航道的交集上。换句话说，如果所需时间大于 $t$ 的航道有 $cnt$ 条，那么虫洞被航道覆盖的次数必须等于 $cnt$（“覆盖”指“被‘所需时间大于 $t$ 的航道’覆盖”）。而这种路径覆盖问题，可以用树上差分解决，这样就可以在 $O(n)$ 复杂度中完成对 $t$ 的判断，即将所需时间大于 $t$ 的航道经过的边的标记都 +1，则标记等于 $cnt$ 的边才可以建造虫洞。由于虫洞只有一个，所以建造在长度最大的边上，所以经过该边所需的时间即为要求的 $t_0$，如果 $maxt-t_0⩽t$ 就说明可以通过一个虫洞使得可以在 $t$ 时间内完成任务。

同时发现，如果可以在 $t$ 时间内完成任务，那肯定可以在 $t+1$ 时间内完成，符合单调性，可以二分，所以复杂度为 $O(n\log n)$.

简要题解

首先预处理 $di{s}_u$ 表示从节点 $u$ 到根节点的路径长度，方便求出 $u_i$ 到 $v_i$ 的距离。如果可以在 $t$ 时间内完成任务，那肯定可以在 $t+1$ 时间内完成，符合单调性，所以二分 $O(\log n)$ 完成任务的时间，再 $O(n)$ 判断合法性。

注意到如果一条线路所需时间已经低于当前二分值 $mid$ 就无需建造虫洞，而大于 $mid$ 的线路必须要建造虫洞，所以虫洞必须在所有大于 $mid$ 的线路的交集上，所以判断时用树上差分把所有线路都 +1（即把路径覆盖到的边都 +1），最后在被覆盖次数为“所需时间大于 $mid$ 的总路径数”的边中选择边权最大的改为虫洞，判断改之后的时间是否小于等于 $mid$ 即可。

参考代码

#include <bits/stdc++.h>
#define int long long
using namespace std;
inline int read(){
	int s = 0, w = 1;
	char ch = getchar();
	for(; ch < '0' || ch > '9'; w *= ch == '-' ? -1 : 1, ch = getchar());
	for(; ch >= '0' && ch <= '9'; s = 10 * s + ch - '0', ch = getchar());
	return s * w;
}
const int MAXN = 300005;
const int MAXLog = 20;
struct Graph{
	struct Edge{
		int to, nxt, w;
	} e[MAXN << 1];
	int head[MAXN], tot;
	void add(int u, int v, int w){
		e[++tot].to = v;
		e[tot].nxt = head[u];
		e[tot].w = w;
		head[u] = tot;
	}
} G;
int N, M, fa[MAXN][MAXLog], dep[MAXN], dis[MAXN], cnt[MAXN];
int s[MAXN], t[MAXN], d[MAXN], maxt, lc[MAXN], maxlog;
void dfs(int u, int lst){
	fa[u][0] = lst, dep[u] = dep[lst] + 1;
	for(int i = G.head[u], v, w; i; i = G.e[i].nxt){
		v = G.e[i].to, w = G.e[i].w;
		if(v == lst) continue;
		dis[v] = w, d[v] = dis[v] + d[u];
		dfs(v, u);
	}
}
int getlca(int u, int v){
	if(dep[u] > dep[v]) swap(u, v);
	for(int i = maxlog; i >= 0; i--){
		if(dep[fa[v][i]] >= dep[u]) v = fa[v][i]; 
	}
	if(u == v) return u;
	for(int i = maxlog; i >= 0; i--){
		if(fa[u][i] != fa[v][i]){
			u = fa[u][i], v = fa[v][i];
		}
	} 
	return fa[u][0];
}
int calc(int u, int lst, int tot){
	int res = 0;
	for(int i = G.head[u], v; i; i = G.e[i].nxt){
		v = G.e[i].to;
		if(v == lst) continue;
		res = max(res, calc(v, u, tot)); 
		cnt[u] += cnt[v];
	}
	if(cnt[u] == tot) res = max(res, dis[u]);
	return res;
}
bool check(int x){
	memset(cnt, 0, sizeof cnt);
	int tot = 0;
	for(int i = 1; i <= M; i++){
		if(d[s[i]] + d[t[i]] - 2 * d[lc[i]] <= x) continue;
		cnt[s[i]]++, cnt[t[i]]++, cnt[lc[i]]--, cnt[lc[i]]--, tot++;
	}
	return maxt - calc(1, 1, tot) <= x;
}
signed main(){
	N = read(), M = read(), maxlog = log2(N) + 1;
	for(int i = 1, u, v, w; i < N; i++){
		u = read(), v = read(), w = read();
		G.add(u, v, w), G.add(v, u, w);
	}
	dfs(1, 1);
	for(int i = 1; i <= maxlog; i++){
		for(int j = 1; j <= N; j++){
			fa[j][i] = fa[fa[j][i - 1]][i - 1];
		}
	}
	for(int i = 1; i <= M; i++){
		s[i] = read(), t[i] = read(), lc[i] = getlca(s[i], t[i]);
		maxt = max(maxt, d[s[i]] + d[t[i]] - (d[lc[i]] << 1));
	}
	int l = 0, r = maxt, mid, res = -1;
	while(l <= r){
		mid = l + r >> 1;
		if(check(mid)){
			res = mid, r = mid - 1;
		} else {
			l = mid + 1;
		}
	}
	cout << res << endl;
	return 0;
}