【ybt高效进阶4-5-4】【luogu P1967】货车运输

货车运输

题目链接：ybt高效进阶4-5-4 / luogu P1967

题目大意

有一些点，然后又一些有权值的边。
然后多组询问，每次给你两个点，要你找一条路径，使得这条路径上权值最小的边的权值最大。（输出权值）
如果没有路径就输出 -1。

思路

那首先我们看到它是找路径，然后路径不是权值相加，而是权值的极值。
自然想到贪心弄一个最大生成树的东西。

那就由图变成了树，然后要找的就变成了树上的路径。
那我们可以考虑用 LCA 来搞数的路径。
然后预处理跳的父亲的时候同时也可以把这么跳经过的路径的最大权值。

然后两个点的询问就变成了跳 LCA，然后在跳的时候把每次跳的那一段的最小权值取一个最小值，就是答案了。

判断是否有路径其实就是判断是否连通，那我们可以用最大生成树的并查集来判断。

代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

struct road {
	int x, y, z;
}ee[50001];
struct node {
	int x, to, nxt;
}e[100001];
int n, m, nn, q;
int fa[10001], x, y;
int le[10001], KK, ans;
int f[21][10001], deg[10001], dis[21][10001];

bool cmp(road x, road y) {
	return x.z > y.z;
}

int find(int now) {//并查集
	if (fa[now] == now) return now;
	return fa[now] = find(fa[now]);
}

void connect(int x, int y) {
	int X = find(x), Y = find(y);
	fa[X] = Y;
}

void add(int x, int y, int z) {//建树
	e[++KK] = (node){z, y, le[x]}; le[x] = KK;
	e[++KK] = (node){z, x, le[y]}; le[y] = KK;
}

void dfs(int now, int father) {
	deg[now] = deg[father] + 1;
	f[0][now] = father;
	for (int i = le[now]; i; i = e[i].nxt)
		if (e[i].to != father) {
			dis[0][e[i].to] = e[i].x;
			dfs(e[i].to, now);
		}
}

int LCA(int x, int y) {
	if (deg[y] > deg[x]) swap(x, y);
	
	for (int i = 20; i >= 0; i--)
		if (deg[f[i][x]] >= deg[y]) {
			ans = min(ans, dis[i][x]);
			x = f[i][x];
		}
	if (x == y) return x;
	
	for (int i = 20; i >= 0; i--)
		if (f[i][x] != f[i][y]) {
			ans = min(ans, dis[i][x]);
			ans = min(ans, dis[i][y]);
			x = f[i][x];
			y = f[i][y];
		}
	
	ans = min(ans, dis[0][x]);
	ans = min(ans, dis[0][y]);
	return f[0][x];
}

int main() {
	memset(dis, 0x7f, sizeof(dis));
	
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= m; i++)
		scanf("%d %d %d", &ee[i].x, &ee[i].y, &ee[i].z);
	
	sort(ee + 1, ee + m + 1, cmp);
	
	for (int i = 1; i <= n; i++) fa[i] = i;
	for (int i = 1; i <= m; i++) {//最大生成树
		int x = find(ee[i].x), y = find(ee[i].y);
		if (x == y) continue;
		
		nn++;
		connect(ee[i].x, ee[i].y);
		add(ee[i].x, ee[i].y, ee[i].z);
		
		if (nn == n - 1) break;
	}
	
	dfs(1, 0);//把弄出的树进行倍增
	for (int i = 1; i <= 20; i++)
		for (int j = 1; j <= n; j++) {
			f[i][j] = f[i - 1][f[i - 1][j]];
			dis[i][j] = min(dis[i - 1][j], dis[i - 1][f[i - 1][j]]);
		}
	
	scanf("%d", &q);
	while (q--) {
		scanf("%d %d", &x, &y);
		
		if (find(x) != find(y)) {
			printf("-1\n");
			continue;
		}
		
		ans = 1e9;
		LCA(x, y);//在跳LCA的过程中统计答案
		printf("%d\n", ans);
	}
	
	return 0;
}