2.P9432 [NAPC-#1] rStage5 - Hard Conveyors2023-09-27

3.P9797 [NERC2018] Guest Student2023-10-28 4.P9847 [ICPC2021 Nanjing R] Crystalfly2023-11-14 5.P9840 [ICPC2021 Nanjing R] Oops, It's Yesterday Twice More2023-11-16 6.P9842 [ICPC2021 Nanjing R] Klee in Solitary Confinement2023-11-17

P9432 [NAPC-#1] rStage5 - Hard Conveyors

感谢此题让我知道了 Dijkstra 的一种新用法。

题意：

给定一棵 $n$ 个节点的无根树以及树上的 $k$ 个关键节点，给定边的长度。有 $q$ 次询问，每次给出 $s,t$ ，问从 $s$ 到 $t$ 且经过至少一个关键节点的路径的最短长度。

分析：

显然经过至少一个关键节点的条件可以分为两种情况判断：

如果从 $s$ 到 $t$ 的简单路径上已经有关键点，那么直接输出 $s$ 到 $t$ 的简单路径长度即可。这个过程显然可以以 $1$ 为根处理出每个节点 $u$ 到节点 $1$ 的距离 $len_u$ ，那么长度 $ans$ 就是 $len_u+len_v-2\times len_{lca(u,v)}$ 。
如果从 $s$ 到 $v$ 的简单路径上没有关键点，那么显然找到最近的关键点 $v$ ，走到 $v$ 再回到简单路径上的方法可以得到最优解。而不妨预处理出每个点到任意一个关键点的最短距离 $dis$ 数组，则路径到任意关键点的最短距离就可以定义为简单路径上 $dis$ 数组的最小值 $mindis$ ，由此答案只需要在 $ans$ 的基础上再加上 $2\times mindis$ 。而多次查询路径上区间有关信息的问题显然可以用线段树 $+$ 树链剖分实现，那么关键就是如何计算每个点到任意一个关键点的最短距离。

这时候就需要 Dijkstra 的经典（神奇逆天）多源最短路写法了：将每个关键点的初始 $dis$ 均设为 $0$ ，再跑普通的堆优化 Dijkstra，此时 $dis$ 数组存储的就是每个点到任意一个关键点的最短距离了。

核心代码如下：

priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > q;

inline void dij() {
	memset(dis, 0x3f, sizeof dis);
	memset(vis, 0, sizeof vis);
	for (int i = 1; i <= k; i++) {
		dis[p[i]] = 0;
		q.push({0, p[i]});
	}
	while (!q.empty()) {
		auto u = q.top().second;
		q.pop();

		if (vis[u]) continue;
		vis[u] = 1;

		for (auto i : G[u]) {
			int v = i.first, w = i.second;
			if (dis[v] > dis[u] + w) {
				dis[v] = dis[u] + w;
				q.push({dis[v], v});
			}
		}
	}
}

剩下的就是经典的普通树剖维护 $dis$ 数组的区间最小值了。

#include <bits/stdc++.h>
#define int long long
using namespace std;

const int maxn = 1e5 + 5;
int n, m, k;
vector<pair<int, int> > G[maxn];
struct data {
	int l, r, dat;
} t[maxn << 2];
int dep[maxn], fa[maxn], siz[maxn], son[maxn], top[maxn], dfn[maxn], rk[maxn], cnt;
int len[maxn];
int dis[maxn], p[maxn];
bool vis[maxn];
priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > q;

inline void dfs1(int u, int f) {
	dep[u] = dep[f] + 1;
	siz[u] = 1;
	for (auto i : G[u]) {
		int v = i.first, w = i.second;
		if (v == f) continue;
		fa[v] = u;
		len[v] = len[u] + w;
		dfs1(v, u);
		siz[u] += siz[v];
		if (siz[son[u]] < siz[v]) son[u] = v;
	}
}

inline void dfs2(int u, int tp) {
	top[u] = tp;
	dfn[u] = ++cnt;
	rk[cnt] = u;
	if (!son[u]) return;
	dfs2(son[u], tp);
	for (auto i : G[u]) {
		int v = i.first;
		if (v == fa[u] or v == son[u]) continue;
		dfs2(v, v);
	}
}

inline void build(int p, int l, int r) {
	t[p].l = l, t[p].r = r;
	if (l == r) {
		t[p].dat = dis[rk[l]];
		return;
	}
	int mid = (l + r) >> 1;
	build(p << 1, l, mid);
	build(p << 1 | 1, mid + 1, r);
	t[p].dat = min(t[p << 1].dat, t[p << 1 | 1].dat);
}

inline int query(int p, int l, int r) {
	if (l <= t[p].l and t[p].r <= r) return t[p].dat;
	int mid = (t[p].l + t[p].r) >> 1, res = 0x3f3f3f3f;
	if (l <= mid) res = min(res, query(p << 1, l, r));
	if (mid < r) res = min(res, query(p << 1 | 1, l, r));
	return res;
}

inline void dij() {
	memset(dis, 0x3f, sizeof dis);
	memset(vis, 0, sizeof vis);
	for (int i = 1; i <= k; i++) {
		dis[p[i]] = 0;
		q.push({0, p[i]});
	}
	while (!q.empty()) {
		auto u = q.top().second;
		q.pop();

		if (vis[u]) continue;
		vis[u] = 1;

		for (auto i : G[u]) {
			int v = i.first, w = i.second;
			if (dis[v] > dis[u] + w) {
				dis[v] = dis[u] + w;
				q.push({dis[v], v});
			}
		}
	}
}

inline int get(int u, int v) {
	int res = 0x3f3f3f3f, ans = 0, uu = u, vv = v;
	while (top[u] != top[v]) {
		if (dep[top[u]] < dep[top[v]]) swap(u, v);
		res = min(res, query(1, dfn[top[u]], dfn[u]));
		u = fa[top[u]];
	}
	if (dep[u] > dep[v]) swap(u, v);
	res = min(res, query(1, dfn[u], dfn[v]));
	ans = len[uu] + len[vv] - len[u] * 2;
	return ans + res * 2;
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	cin >> n >> m >> k;
	for (int i = 1; i < n; i++) {
		int u, v, w;
		cin >> u >> v >> w;
		G[u].push_back({v, w});
		G[v].push_back({u, w});
	}
	for (int i = 1; i <= k; i++) cin >> p[i];
	dij();
	dfs1(1, 1);
	dfs2(1, 1);
	build(1, 1, n);
	for (int i = 1; i <= m; i++) {
		int u, v;
		cin >> u >> v;
		cout << get(u, v) << "\n";
	}
}