LOJ 137 最小瓶颈路（加强版）Kruskal重构树+RMQ LCA

Problem Description

给出一个 $n$ 个点 $m$ 条边的无向连通图，无自环重边，每条边有一个正权值 $w$ 。

进行 $q$ 次询问，每次给出两个不同点 $u$ 和 $v$ ，求一条从 $u$ 到 $v$ 的路径上边权的最大值最小是多少。

Input

第一行输入两个整数 $n,m$ $(n\le 7\times 10^4,m\le 10^5,q\le 10^7)$。

接下来 $m$ 行输入三个整数 $a_i,b_i,w_i(a_i\ne b_i)$ $(1\le a_i,b_i\le n,1\le w_i\le 10^9+7)$，表示一条边$(a_i,b_i)$ ，边权为 $w_i$ 。

接下来一行输入一个整数 $q$ ，表示询问数量。

接下来一行四个整数 $A,B,C,P$ $(0\le A<P,0\le C<P,P(B+1)<2^{31}-1)$，表示查询的生成方式。

输入压缩方法是：读入 $4$ 个整数 $A,B,C,P$ ，每次询问调用以下函数生成 $u$ 和 $v$：

int A, B, C, P;
inline int rnd() {return A = (A * B + C) % P;}

每次询问时的调用方法为：

u = rnd() % n + 1, v = rnd() % n + 1;

如何 $u$ 和 $v$ 相等则答案为 $0$ 。

Output

输出一个整数，表示所有询问答案之和模 $10^9+7$的值。

Solution

对于图上两点之间所有路径的最大值最小，我们可以显然地想到这就等同于对应图的最小生成树的对应两点之间的边权最大值，这可以由简单的反证法证明。

那么由此我们可以得到一个简单直接的想法：求出无向图的最小生成树，做 $LCA$ 的同时维护路径边权最大值，复杂度为 $O(mlogm+qlogn)$。

这是 $easy$ $version$ 的正确做法，但是在加强版中由于 $(q\le 10^7)$ ，在 $1000ms$ 的时限内 $O(logn)$查询显然会 $TLE$ ，只能 $O(1)$ 查询。

由于是求最小生成树两点之间的边权最大值，我们考虑到 $Kruskal$ 重构树的两个重要性质：

1. 所有叶子节点的映射对应原图的节点。
2. 任意两个叶子节点的 $LCA$ 的权值对应原图两个节点之间的边权最大值。

这也就意味着我们在 $Kruskal$ 重构树中只需求出 $LCA$ 是什么，而不需要去维护路径，那么此时我们便能通过对 $dfs$ 序 $RMQ$ 求 $LCA$ 来实现 $O(1)$ 查询。

Code

#include <bits/stdc++.h>
#define endl '\n'
using namespace std;
constexpr int N = 2e5 + 10, M = 4e5 + 10, mod = 1e9 + 7;
int A, B, C, P;
inline int rnd() {return A = (A * B + C) % P;}
struct DSU {
	vector<int>p;
	DSU(int n) : p(n) { iota(p.begin(), p.end(), 0); }
	int leader(int x) {
		while (x != p[x])x = p[x] = p[p[x]];
		return x;
	}
	bool same(int x, int y) { return leader(x) == leader(y); }
	bool merge(int x, int y) {
		x = leader(x);
		y = leader(y);
		if (x == y)return false;
		p[y] = x;
		return true;
	}
} dsu(N);
int n, m, cntn;
tuple<int, int, int> edge[N];
int val[N];
int st[20][M], logn[M];
int dfn[N], pos[M], tot = 0;
int head[N], e[N], ne[N], idx = 0;
inline void addedge(int a, int b) {
	e[idx] = b, ne[idx] = head[a], head[a] = idx++;
}
void dfs(int u) {
	dfn[u] = ++tot;
	pos[tot] = u;
	for (int i = head[u]; i != -1; i = ne[i]) {
		dfs(e[i]);
		pos[++tot] = u;
	}
}
void multiply_init() {
	logn[1] = 0;
	for (int i = 2; i < M; i++)logn[i] = logn[i / 2] + 1;
	for (int i = 1; i <= tot; i++)st[0][i] = pos[i];
	for (int j = 1; j <= 19; j++) {
		for (int i = 1; i + (1 << j) - 1 <= tot; i++) {
			int l = st[j - 1][i], r = st[j - 1][i + (1 << (j - 1))];
			st[j][i] = dfn[l] < dfn[r] ? l : r;
		}
	}
}
int lca(int a, int b) {
	int l = dfn[a], r = dfn[b];
	if (l > r)swap(l, r);
	int s = logn[r - l + 1];
	l = st[s][l], r = st[s][r - (1 << s) + 1];
	return dfn[l] < dfn[r] ? l : r;
}
void ex_kruskal() {
	cntn = n;
	sort(edge + 1, edge + m + 1);
	for (int i = 1; i <= m; i++) {
		auto [w, a, b] = edge[i];
		if (!dsu.same(a, b)) {
			val[++cntn] = w;
			addedge(cntn, dsu.leader(a)), addedge(cntn,  dsu.leader(b));
			dsu.merge(cntn, a);
			dsu.merge(cntn, b);
			if (cntn == 2 * n - 1)break;
		}
	}
}
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	memset(head, -1, sizeof head);
	cin >> n >> m;
	for (int i = 1; i <= m; i++) {
		int a, b, w;
		cin >> a >> b >> w;
		edge[i] = {w, a, b};
	}
	ex_kruskal();
	dfs(cntn);
	multiply_init();
	int q;
	cin >> q;
	cin >> A >> B >> C >> P;
	long long ans = 0;
	while (q--) {
		int u = rnd() % n + 1, v = rnd() % n + 1;
		if (u == v)continue;
		ans = (ans + val[lca(u, v)]) % mod;
	}
	cout << ans << endl;
}