题目描述
A 国有 n 座城市，编号从 1 到 n，城市之间有 m 条双向道路。每一条道路对车辆都有重量限制，简称限重。现在有 q 辆货车在运输货物， 司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。
输入格式：
输入文件名为 truck.in。
输入文件第一行有两个用一个空格隔开的整数 n，m，表示 A 国有 n 座城市和 m 条道
路。 接下来 m 行每行 3 个整数 x、 y、 z，每两个整数之间用一个空格隔开，表示从 x 号城市到 y 号城市有一条限重为 z 的道路。注意： x 不等于 y，两座城市之间可能有多条道路 。
接下来一行有一个整数 q，表示有 q 辆货车需要运货。
接下来 q 行，每行两个整数 x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意： x 不等于 y 。
输出格式：
输出文件名为 truck.out。
输出共有 q 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。如果货
车不能到达目的地，输出-1。
输入样例
4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3
输出样例
3
-1
3
说明
对于 30%的数据，0 < n < 1,000，0 < m < 10,000，0 < q< 1,000；
对于 60%的数据，0 < n < 1,000，0 < m < 50,000，0 < q< 1,000；
对于 100%的数据，0 < n < 10,000，0 < m < 50,000，0 < q< 30,000，0 ≤ z ≤ 100,000。
题目分析：
首先题目要求求出图中任意两点间的最大限重
通俗地讲，就是求出任意两点间路径中最小边权的最大值
也就是通常说的最大瓶颈路
知道这点就不难想到
先对图求一次最大生成树
在用得出最大生成树作为新图继续进行操作
在一棵树上任意两点的路径是唯一的
怎样快速的寻找任意两点的路径？？？
这里我们很容易想到LCA
如果我们通过DFS或BFS寻找
将会产生大量无意义的搜索
而通过求出u和v的LCA
我们可以直接从u和v向上寻找他们的LCA
这样搜索的路径便只有一条
在寻找时记录最小值就好了
对于两点是否互相可达
可直接利用求最大生成树时的father[]数组
若待查询的u和v不在一个集合内，则直接输出-1
这里为了保证LCA的效率
我用了树剖求解
不会树剖求LCA的小伙伴看这里~
剩下具体解释见代码注释
********************************
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
int read()
{
int f=1,x=0;
char ss=getchar();
while(ss<‘0‘||ss>‘9‘){if(ss==‘-‘)f=-1;ss=getchar();}
while(ss>=‘0‘&&ss<=‘9‘){x=x*10+ss-‘0‘;ss=getchar();}
return f*x;
}
void print(int x)
{
if(x<0){putchar(‘-‘);x=-x;}
if(x>9)print(x/10);
putchar(x%10+‘0‘);
}
int n,m;
int tot;
struct node{int v,w,nxt;}E[100010];
struct node2{int u,v,w;}edge[100010];
int head[100010];
int father[100010];
int fa[100010],dep[100010],son[100010],size[100010],top[100010];
int path[500010];//path树剖时记录节点u到fa[u]的限重
bool cmp(node2 a,node2 b){return a.w>b.w;}
void add(int u,int v,int w)
{
E[++tot].nxt=head[u];
E[tot].v=v;
E[tot].w=w;
head[u]=tot;
}
int find(int x)
{
if(x==father[x]) return x;
else return father[x]=find(father[x]);
}
void kruskal()
{
int num=0;
for(int i=1;i<=n;i++) father[i]=i;
sort(edge+1,edge+1+m,cmp);
for(int i=1;i<=m;i++)
{
int u=edge[i].u,v=edge[i].v;
int fu=find(u),fv=find(v);
if(fu!=fv)
{
father[fu]=fv; num++;
add(u,v,edge[i].w);
add(v,u,edge[i].w);//构造新图
if(num==n-1) break;
}
}
}
void dfs1(int u,int pa)
{
size[u]=1;
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(v==pa) continue;
dep[v]=dep[u]+1; fa[v]=u; path[v]=E[i].w;
dfs1(v,u);
size[u]+=size[v];
if(size[v]>size[son[u]]) son[u]=v;
}
}
void dfs2(int u,int tp)
{
top[u]=tp;
if(son[u]) dfs2(son[u],tp);
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(v==fa[u]||v==son[u]) continue;
dfs2(v,v);
}
}
int getmin(int gra,int u,int v)
{
int ans=1e9;//若u/v不等于他们的lca，则一直向上迭代，更新最小值
while(u!=gra){ans=min(ans,path[u]);u=fa[u];}
while(v!=gra){ans=min(ans,path[v]);v=fa[v];}
return ans;
}
int main()
{
n=read();m=read();
for(int i=1;i<=m;i++)
edge[i].u=read(),edge[i].v=read(),edge[i].w=read();
kruskal();//求最大生成树
dep[1]=1; path[1]=1e9;
dfs1(1,-1); dfs2(1,1);//树剖
int q=read();
while(q--)
{
int u=read(),v=read();
if( find(u)!=find(v) )
{print( -1 );printf("\n"); continue;}
int tu=u,tv=v;//求u和v的LCA
while(top[tu]!=top[tv])
{
if(dep[top[tu]]>dep[top[tv]]) tu=fa[top[tu]];
else tv=fa[top[tv]];
}
int gra=dep[tu]<dep[tv] ?tu:tv;
print( getmin(gra,u,v) );printf("\n");//寻找最小限重
}
return 0;
}