洛谷 P1967 [NOIP2013 提高组] 货车运输（最大生成树，最近公共祖先）

[NOIP2013 提高组] 货车运输

题目描述

A 国有 $n$ 座城市，编号从 $1$ 到 $n$，城市之间有 $m$ 条双向道路。每一条道路对车辆都有重量限制，简称限重。

现在有 $q$ 辆货车在运输货物， 司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。

输入格式

第一行有两个用一个空格隔开的整数 $ n,m$，表示 $A$ 国有 $ n$ 座城市和 $m$ 条道路。

接下来 $m$ 行每行三个整数 $x,y,z$，每两个整数之间用一个空格隔开，表示从 $x $ 号城市到 $ y $ 号城市有一条限重为 $z$ 的道路。
注意： $x\ne y$，两座城市之间可能有多条道路 。

接下来一行有一个整数 $q$，表示有 $q$ 辆货车需要运货。

接下来 $q$ 行，每行两个整数 $x,y$，之间用一个空格隔开，表示一辆货车需要从 $x$ 城市运输货物到 $y$ 城市，保证 $x\ne y$

输出格式

共有 $q$ 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。
如果货车不能到达目的地，输出 $-1$。

样例 #1

样例输入 #1

4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3

样例输出 #1

3
-1
3

提示

对于 $30\%$ 的数据，$1\le n<1000$，$1\le m<10,000$，$1\le q<1000$；

对于 $60\%$ 的数据，$1\le n<1000$，$1\le m<5\times 10^4$，$1\le q<1000$；

对于 $100\%$ 的数据，$1\le n<10^4$，$1\le m<5\times 10^4$，$1 \le q< 3\times 10^4 $，$0\le z\le 10^5$。

1、 边稀疏图，用Kruskal 算法生成最大生成树
2、 f[i][k] 表示i点向上跑 2^k 步， 所到达的点， 显然f[y][j] = f[f[y][j - 1]][j - 1];
	d[i][k] 表示从i点向上跑 2^k 步， 其中最短的距离， 转移方程：
	d[y][j] = min(d[y][j - 1], d[f[y][j - 1]][j - 1]);
	初始化： d[y][0] = edge(x----->y) , 从x点遍历到y点的边长

#include 
using namespace std;
const int N = 1e4 + 10, M =1e5 + 10, inf = 0x3f3f3f3f;

int f[N][20];
int d[N][20];	// d[i][k] 表示从i点向上跑 2^k 步， 其中最短的距离
int deep[N];
int fa[N];
int ver[M], Next[M], head[N], edge[M], tot;
int n, m, query, t;

struct rec
{
	int x, y, z;
	bool operator<(const rec& rhs) const
	{
		return z > rhs.z;
	}
}w[M];

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

void add(int x, int y, int z)
{
	ver[++tot] = y, edge[tot] = z, Next[tot] = head[x], head[x] = tot;
}

void bfs(int st)
{
	queue<int> q;
	q.push(st); deep[st] = 1;
	while(q.size())
	{
		int x = q.front(); q.pop();
		for(int i = head[x]; i; i = Next[i])
		{
			int y = ver[i];
			if(deep[y]) continue;
			deep[y] = deep[x] + 1;
			f[y][0] = x, d[y][0] = edge[i];
			for(int j = 1; j <= t; ++j)
			{
				f[y][j] = f[f[y][j - 1]][j - 1];
				d[y][j] = min(d[y][j - 1], d[f[y][j - 1]][j - 1]);
			}
			q.push(y);
		}
	}
}

int calc(int x, int y)
{
	int minx = inf, miny = inf;
	if(deep[x] > deep[y])
		swap(x, y);
	for(int i = t; i >= 0; --i)
	{
		if(deep[f[y][i]] >= deep[x])
		{
			miny = min(miny, d[y][i]);
			y = f[y][i];
		}
	}
	if(x == y)
	{
		return miny;
	}
	for(int i = t; i >= 0; --i)
	{
		if(f[x][i] != f[y][i])
		{
			minx = min(minx, d[x][i]), miny = min(miny, d[y][i]);
	//		printf("miny = %d\n", miny);
			x = f[x][i], y = f[y][i];
		}
	}
	minx = min(minx, d[x][0]), miny = min(miny, d[y][0]);
	return min(minx, miny);
}

int main()
{
	scanf("%d%d", &n, &m);
	t = (int)(log(n) / log(2)) + 1;
	for(int i = 1; i <= m; ++i)
	{
		scanf("%d%d%d", &w[i].x, &w[i].y, &w[i].z);
	}
	sort(w + 1, w + m + 1);
	for(int i = 1; i <= n; ++i)
		fa[i] = i;
	for(int i = 1; i <= m; ++i)
	{
		int x = get(w[i].x), y = get(w[i].y);
		if(x == y) continue;
		fa[x] = y;
		add(w[i].x, w[i].y, w[i].z); add(w[i].y, w[i].x, w[i].z);
	}
	for(int i = 1; i <= n; ++i)
	{
		if(!deep[i])
		{
			bfs(i);
		}
	}
	int x, y;
	scanf("%d", &query);
	for(int i = 0; i < query; ++i)
	{
		scanf("%d%d", &x, &y);
		if(get(x) != get(y))
			printf("-1\n");
		else{
			printf("%d\n", calc(x, y));	
		}
	}
	return 0;
}