[蓝桥杯 2023 省 A] 网络稳定性

题目：P9235 [蓝桥杯 2023 省 A] 网络稳定性
参考：P9235 [蓝桥杯 2023 省 A] 网络稳定性 题解

---

思路来自题解 P9235 [蓝桥杯 2023 省 A] 网络稳定性

化简题意后发现，这题本质是将边按边权从大到小排序后依次插入原图，询问两个点在什么时候会连通，允许离线。
每插入一条边本质就是在合并两个连通块，很自然地想到启发式合并。
利用启发式合并的思想，我们将每个询问挂在它的两个端点上，在合并两个联通块时，处理较小的连通块中的询问。
判断询问是否已成立的方法也很简单，只需查询该询问中的另一个端点是否在我们将要合并的连通块内即可，时间复杂度 O(α(n))。
对于未成立的询问，只需将其合并到另一个连通块内便于之后查询即可。
有些读者可能发现一个询问在两个点上，会不会造成重复查询呢？会不会影响该做法的正确性呢？请自行思考，理解它才真正理解了本做法。
时间复杂度 O(nlog⁡nα(n))。

感觉思路很妙但是代码我看不懂orz
总之是从大到小插入边，用并查集判断询问的两个点是否连通了

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <map> 
using namespace std;

const int N = 100005, M = 300005;

int fa[N], sz[N];
vector<int> tq[N];//挂在节点上的询问序号 

struct Edge
{
	int u, v, w;
}e[M], qr[N];
bool cmp(Edge a, Edge b)
{
	return a.w > b.w;
}

int find(int x)
{
	if (fa[x] == x) return x;
	return fa[x] = find(fa[x]);
}

int main()
{
	int n, m, q;
	cin >> n >> m >> q;
	for (int i = 1; i <= n; i++)//记得初始化（说我自己呢 
	{
		fa[i] = i;
		sz[i] = 1;
	}
	for (int i = 0; i < m; i++)
		cin >> e[i].u >> e[i].v >> e[i].w;
	sort(e, e + m, cmp);//边权从大到小排序 
	for (int i = 0; i < q; i++)
	{
		//对于询问qr来说，u、v是询问的两个点，w是答案 
		cin >> qr[i].u >> qr[i].v;
		qr[i].w = -1;//答案记初值 
		//两边都挂上 
		tq[qr[i].u].push_back(i);
		tq[qr[i].v].push_back(i);
	}
	
	for (int i = 0; i < m; i++)
	{
		int u = find(e[i].u), v = find(e[i].v);
		//我一开始以为不会有同一块的...结果因为加了太多0re了，debug好久还是我弟找出来的，以后还是都加上吧 
		if (u == v) continue;
		if (sz[u] > sz[v]) swap(u, v);
		//u块头比v小 
		for (auto t : tq[u])//遍历小块上的询问 
		{
			if (qr[t].w != -1) continue;//记得之前通过就别动了，不然一直更新就不是最小值了 
			int tu = find(qr[t].u), tv = find(qr[t].v);
			//如果这个询问的两个点分别在当前边两个点块上，答案就是当前边权
			//否则就把询问挂到v上（因为合并后v是头了，只会处理v上的询问 
			if ((tu == u && tv == v) || (tu == v && tv == u))
				qr[t].w = e[i].w;
			else
				tq[v].push_back(t);
		} 			
		//合并 
		fa[u] = v;
		sz[v] += sz[u];
	}
	for (int i = 0; i < q; i++)
	{
		cout << qr[i].w << endl; 
	 } 
	return 0;
 } 

---

kruskal重构树+lca

重构树听上去高端，实则就是在 kruskal 建最大生成树的过程中额外建点、赋权。
比如，u 和 v 当前不在一个集合里，通过 w 这条边合并时。
新开一个点 x，令 x 是 u 和 v 的父亲，而 x 的权值为 w。
查询时，查 u 和 v 的 LCA 的权值即可，即为最大连通路径上的最小连通权值。
因为按权值从大到小遍历，已经通过权值大的边，使得点之间尽可能连通了。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <map> 
#include <cmath>
using namespace std;

const int N = 400005, M = 300005;//N <- n + m 

int fa[N], f[20][N], dep[N], w[N], vis[N];
vector<int> tr[N];
struct Edge
{
	int u, v, w;
}e[M];
bool cmp(Edge a, Edge b)
{
	return a.w > b.w;
}

int find(int x)
{
	if (fa[x] == x) return x;
	return fa[x] = find(fa[x]);
}

void dfs(int x, int p)
{
	vis[x] = 1;
	f[0][x] = p;
	dep[x] = dep[p] + 1;
	for (int i = 1; i <= log2(dep[x]); i++)
		f[i][x] = f[i - 1][f[i - 1][x]];
	for (auto y : tr[x])
	{
		if (!vis[y]) dfs(y, x);
	}
}

int lca(int x, int y)
{
	if (dep[x] < dep[y]) swap(x, y);
	int d = dep[x] - dep[y];
	for (int i = 19; i >= 0; i--)
		if (d >> i & 1) x = f[i][x];
	if (x == y) return x;
	for (int i = 19; i >= 0; i--)
	{
		if (f[i][x] != f[i][y])
		{
			x = f[i][x];
			y = f[i][y];
		}
	}
	return f[0][x];
}

int main()
{
	int n, m, q;
	cin >> n >> m >> q;
	for (int i = 1; i <= n + m; i++)
		fa[i] = i; 
	for (int i = 0; i < m; i++)
	{
		cin >> e[i].u >> e[i].v >> e[i].w;
	}
	sort(e, e + m, cmp);
	int cur = n;
	for (int i = 0; i < m; i++)
	{
		int u = find(e[i].u), v = find(e[i].v);//要对所在块的头操作 
		if (u != v)
		{
			cur++;
			fa[u] = fa[v] = cur;
			tr[cur].push_back(u);
			tr[cur].push_back(v);
			w[cur] = e[i].w;
		}
	}
	for (int i = cur; i >= 1; i--)
		if (!vis[i]) dfs(i, 0);
	for (int i = 0; i < q; i++)
	{
		int x, y;
		cin >> x >> y;
		if (find(x) != find(y)) cout << -1 << endl;
		else cout << w[lca(x, y)] << endl;
	}
	return 0;
 }