洛谷 P1967 货车运输（倍增+LCA）

A国有nn座城市，编号从 11到nn，城市之间有 mm 条双向道路。每一条道路对车辆都有重量限制，简称限重。现在有 qq 辆货车在运输货物， 司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。

输入输出格式

输入格式：

 

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

接下来 mm行每行33个整数 x, y, zx,y,z，每两个整数之间用一个空格隔开，表示从 xx号城市到yy号城市有一条限重为 zz的道路。注意： xx 不等于 yy，两座城市之间可能有多条道路 。

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

接下来 q 行，每行两个整数 x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意：x 不等于 y 。

 

输出格式：

 

共有 qq 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。如果货车不能到达目的地，输出-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\%30%的数据，0 < n < 1,000,0 < m < 10,000,0 < q< 1,0000<n<1,000,0<m<10,000,0<q<1,000；

对于 60\%60%的数据，0 < n < 1,000,0 < m < 50,000,0 < q< 1,0000<n<1,000,0<m<50,000,0<q<1,000；

对于 100\%100%的数据，0 < n < 10,000,0 < m < 50,000,0 < q< 30,000,0 ≤ z ≤ 100,0000<n<10,000,0<m<50,000,0<q<30,000,0≤z≤100,000。

解题思路

求x到y最多可以运输多少货物，不用考虑路程，就是说，只要保证x到y所经过的边的最小值最大，就是让边的权值尽量大，求一次最大生成树，就可以满足以上条件。然后要在生成树中找到x到y的路径，在不重复走的情况下，x到y只有一条路。就是经过x和y的最近公共祖先（LCA）的路。用倍增求LCA。

LCA推荐http://www.cnblogs.com/yyf0309/p/5972701.html

代码如下

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
#include <cmath>
#define maxn 10005
#define INF 0x3f3f3f3f
using namespace std;
struct Line{
	int l, r, w;
	Line(int l, int r, int w): l(l), r(r), w(w){	}
	bool operator<(const Line& a){
		return w > a.w;
	}
};
struct T{
	int r, w;
	T(int r, int w): r(r), w(w){	}
};
vector<Line> line;
int parent[maxn];
vector<T> g[maxn];
bool vis[maxn];
int w[maxn][25];   //i到往上2^j位置的最小边权 
int fa[maxn][25];  //i往上跳2^j个的位置 
int deep[maxn];   //i的深度 
void dfs(int x, int d)  //记录节点的深度，以及fa[][0],w[][0],即父亲节点和连接自己和父亲节点的边权 
{
	for(int i = 0; i < g[x].size(); i ++){
		int y = g[x][i].r;
		if(!vis[y]){
			vis[y] = true;
			deep[y] = d + 1;
			fa[y][0] = x;
			w[y][0] = g[x][i].w;
			dfs(y, d + 1); 
		}
	}
}
int f(int p)
{
	if(p == parent[p])
		return p;
	else 
		return parent[p] = f(parent[p]);
}
int lca(int x, int y)
{
	if(deep[x] > deep[y])  //确保y更深 
		swap(x, y);
	int ans = INF;
	for(int i = 20; i >= 0; i --){  //2^k组成的相加的数，可以得到任何数 
		if(deep[fa[y][i]] >= deep[x]){  //通过这个循环，可以使deep[x]==deep[y] 
			ans = min(ans, w[y][i]);
			y = fa[y][i];           //先更新ans再改变y 
		}
	}
	if(y == x)  //如果x和y相同，已经找到，返回答案 
		return ans;
	for(int i = 20; i >= 0; i --){
		if(fa[y][i] != fa[x][i]){    //找到x·和y·不相等且深度最小的，即x·不等于y·且父节点相同 
			ans = min(ans, min(w[y][i], w[x][i]));
			y = fa[y][i];
			x = fa[x][i];
		}
	}
	ans = min(ans, min(w[y][0], w[x][0])); //得到最后答案 
	return ans;
}
int main()
{
	int n, m;
	while(cin >> n >> m){
		for(int i = 0; i < m; i ++){
			int l, r, w;
			scanf("%d%d%d", &l, &r, &w);
			line.push_back(Line(l, r, w)); 
		}
		sort(line.begin(), line.end());
		for(int i = 1; i <= n; i ++)
			parent[i] = i;
		int cnt = 1;
		for(int i = 0; i < m; i ++){  //找最小生成树 
			int l = f(line[i].l);
			int r = f(line[i].r);
			if(l != r){
				parent[l] = r;
				g[line[i].l].push_back(T(line[i].r, line[i].w)); //建图 
				g[line[i].r].push_back(T(line[i].l, line[i].w));
				cnt ++;
				if(cnt == n)
					break;
			}			
		}
		memset(vis, 0, sizeof(vis));
		for(int i = 1; i <= n; i ++){
			if(!vis[i]){    
				vis[i] = true;
				fa[i][0] = i;
				w[i][0] = INF;
				deep[i] = 1;
				dfs(i, 1);  //dfs 
			}
		}
		
		for(int i = 1; i <= 20; i ++){   //处理fa[][]与w[][] 
			for(int j = 1; j <= n; j ++){
				fa[j][i] = fa[fa[j][i - 1]][i - 1]; //j往上跳2^(i-1)的点再往上跳2^(i-1) 
				w[j][i] = min(w[j][i - 1], w[fa[j][i - 1]][i - 1]);//j到j往上2^(i-1)的点x的最大流量
			}                                                      //和x再往上2^(i-1)的最大流量中的较小值 
		}	
		int k;
		cin >> k;
		for(int i = 1; i <= k; i ++){
			int x, y;
			scanf("%d%d", &x, &y);
			if(f(x) != f(y))  //如果不在一个集合，说明不能到达 
				printf("-1\n");
			else
				printf("%d\n", lca(x, y)); 	
		} 
	}
	return 0;
}