[LGOJ2245]星际导航——[kruskal重构树+LCA]

最新推荐文章于 2022-05-18 20:25:39 发布

sleepyNick

最新推荐文章于 2022-05-18 20:25:39 发布

阅读量256

点赞数

CC 4.0 BY-SA版权

分类专栏： kruskal重构树图论 LCA

本文链接：https://blog.csdn.net/Mega_Aspirin/article/details/102905146

图论同时被 3 个专栏收录

7 篇文章

订阅专栏

LCA

5 篇文章

订阅专栏

kruskal重构树

1 篇文章

订阅专栏

本文深入探讨了Kruskal重构树算法，这是一种在图论中用于寻找最小生成树的有效方法。通过将边上的端点与虚点连接，转换为点权，重构树能够高效地解决特定类型的路径问题。文章提供了详细的算法实现代码，包括如何构建重构树，以及如何利用重构树上的最低公共祖先(LCA)来确定路径上最大边权的最小值。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述
【题意分析】

知识点：kruskal重构树

构建重构树的过程：kruskal时，将边上的端点全都和一个虚点相连，这个点的点权就是原来的边权。

性质：重构树上的LCA就是两边所有路径危险值最大的最小值。

Code：

//KajKeusaka
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
#define MAXN 300000
using namespace std;

struct fls {int to, next;} edge[MAXN << 1];
struct Node {int x, y, v;} data[MAXN];

int top[MAXN], head[MAXN << 1], f[MAXN], father[MAXN], depth[MAXN];
int size[MAXN], son[MAXN], val[MAXN], n, m, cnt, Cnt;

inline int read () {
	register int s = 0, w = 1;
	register char ch = getchar ();
	while (! isdigit (ch)) {if (ch == '-') w = -1; ch = getchar ();}
	while (isdigit (ch)) {s = (s << 3) + (s << 1) + (ch ^ 48); ch = getchar ();}
	return s * w;
}

int getfather (int x) {return (x == f[x]) ? x : f[x] = getfather (f[x]);}
inline void connect2 (int u, int v) {edge[++Cnt].to = v, edge[Cnt].next = head[u], head[u] = Cnt;}
inline bool cmp (Node a, Node b) {return a.v < b.v;}

inline int LCA (int x, int y) {
	while (top[x] != top[y]) {
		if (depth[top[x]] < depth[top[y]]) swap (x, y);
		x = father[top[x]];
	}
	return (depth[x] > depth[y]) ? y : x;
}

void DFS1 (int now, int fa, int d) {
	depth[now] = d, father[now] = fa, size[now] = 1; int maxson = -1;
	for (register int i = head[now]; i; i = edge[i].next) {
		int v = edge[i].to; if (v == fa) continue;
		DFS1 (v, now, d + 1), size[now] += size[v];
		if (size[v] > maxson) {son[now] = v, maxson = size[v];}
	}
}

void DFS2 (int now, int top_heavy) {
	top[now] = top_heavy; if (! son[now]) return;
	DFS2 (son[now], top_heavy);
	for (register int i = head[now]; i; i = edge[i].next) {
		int v = edge[i].to;
		if (v != father[now] && v != son[now]) DFS2 (v, v);
	}
}

int main () {
	n = read (), m = read ();
	for (register int i = 1; i <= m; i++)
		data[i].x = read (), data[i].y = read (), data[i].v = read ();
	sort (data + 1, data + m + 1, cmp); int now = n;
	for (register int i = 1; i <= n * 2; i++) f[i] = i;
	for (register int i = 1; i <= m; i++) {
		int x = data[i].x, y = data[i].y;
		int xx = getfather (x), yy = getfather (y);
		if (xx != yy) {
			f[xx] = f[yy] = ++now;
			connect2 (xx, now), connect2 (now, xx),
			connect2 (yy, now), connect2 (now, yy);
			val[now] = data[i].v;
		}
	}
	for (register int i = now; i; i--)
		if (! depth[i]) DFS1 (i, 0, 1), DFS2 (i, i);
	int q = read ();
	for (register int I = 1; I <= q; I++) {
		int u = read (), v = read ();
		if (getfather (u) != getfather (v)) puts ("impossible");
		else printf ("%d\n", val[LCA (u, v)]);
	}
	return 0;
}
/*
4 5
1 2 5
1 3 2
2 3 11
2 4 6
3 4 4
3
2 3
1 4
1 2
*/