洛谷P1967 [NOIP2013 提高组] 货车运输

题目描述

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

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

输入格式

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

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

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

接下来 qq 行，每行两个整数 x,yx,y，之间用一个空格隔开，表示一辆货车需要从 xx 城市运输货物到 yy 城市，保证 x \neq yx=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% 的数据，1 \le n < 10001≤n<1000，1 \le m < 10,0001≤m<10,000，1\le q< 10001≤q<1000；

对于 60\%60% 的数据，1 \le n < 10001≤n<1000，1 \le m < 5\times 10^41≤m<5×104，1 \le q< 10001≤q<1000；

对于 100\%100% 的数据，1 \le n < 10^41≤n<104，1 \le m < 5\times 10^41≤m<5×104，1 \le q< 3\times 10^41≤q<3×104，0 \le z \le 10^50≤z≤105。

思路：这个题目虽然是分在了《最小生成树》题组，但是还要用到LCA的知识，所以首先不管怎么说都要同时先掌握最小生成树算法和求LCA算法（如倍增）。这道题的解法是先求出最大生成树，然后把这个树存起来，再来这棵树上面求lca即可，cost则为最小边权值，合理性等具体看代码及其注释。

#include<bits/stdc++.h>
using namespace std;
//此题利用最大生成树的合理性在于对于每条边，若是遍历到但是发现它所连接的两个点已经被连接，那么就说明肯定不用这个点， 
//因为需要用经过这两个点的路径肯定有更优的选择，由于一开始就已经有边权值比较大的边去连接它们了 
const int maxn=1e4+5,maxm=5e4+5,inf=0x3f3f3f3f;
int FA[maxn],fa[maxn][31]={},cost[maxn][31]={},dep[maxn]={};
void make()
{
	iota(FA,FA+maxn,0);
}
int find(int x)
{
	return FA[x]==x?x:FA[x]=find(FA[x]);
}
bool same(int a,int b)
{
	return find(a)==find(b);
}
void unite(int a,int b)
{
	a=find(a);
	b=find(b);
	FA[a]=b;
}
struct ed{
	int u,v,w;
	bool operator<(const ed &a)const
	{
		return w>a.w;
	}
}edg[maxm];
struct edge{
	int v,w;
};
vector<edge> g[maxn];
int n,m;
void read()
{
	cin>>n>>m;
	for(int i=0;i<m;i++)
	{
		cin>>edg[i].u>>edg[i].v>>edg[i].w;
	}
}
void kruskal()
{
	sort(edg,edg+m);
	for(int i=0;i<m;i++)
	{
		if(same(edg[i].u,edg[i].v))continue;
		else//在这个过程中顺便保存边，建树 
		{
			g[edg[i].u].push_back({edg[i].v,edg[i].w});
			g[edg[i].v].push_back({edg[i].u,edg[i].w});
			unite(edg[i].u,edg[i].v);
		}
	}
}

void dfs(int u,int fno)
{
	fa[u][0]=fno;
	dep[u]=dep[fno]+1;
	for(int i=1;i<31;i++)
	{
		fa[u][i]=fa[fa[u][i-1]][i-1];
		//cost[u][i]=cost[fa[u][i-1]][i-1]+cost[u][i-1];
		cost[u][i]=min(cost[fa[u][i-1]][i-1],cost[u][i-1]);
	}
	for(auto e:g[u])
	{
		int v=e.v,w=e.w;
		if(v==fno)continue;
		cost[v][0]=w;
		dfs(v,u);
	}
}
int lca(int x,int y)//直接求最小边值 
{
	if(dep[x]>dep[y])swap(x,y);
	int tmp=dep[y]-dep[x],ans=inf;
	for(int i=0;tmp;i++,tmp>>=1)
	{
		if(tmp&1)
		{
			//ans+=cost[y][i];
			ans=min(ans,cost[y][i]);
			y=fa[y][i];
		}
	}
	if(x==y)return ans;
	for(int i=30;i>=0;i--)
	{
		if(fa[x][i]!=fa[y][i])
		{
			//ans+=cost[x][i]+cost[y][i];
			ans=min(min(cost[x][i],cost[y][i]),ans);
			x=fa[x][i];
			y=fa[y][i];
		}
	}
	//ans+=cost[x][0]+cost[y][0];
	ans=min(min(cost[x][0],cost[y][0]),ans);
	return ans;
}
int main()
{
	ios_base::sync_with_stdio(false),cin.tie(nullptr);
	make();
	read();
	kruskal();
	//最大生成树已经找到接下来就是用lca求答案 
	dfs(1,0);
	int q;
	cin>>q;
	while(q--)
	{
		int x,y;
		cin>>x>>y;
		int ans=lca(x,y);
		cout<<(ans?ans:-1)<<"\n";
	}
	
	return 0;
}