洛谷 P1967 货车运输【生成树+树剖/LCA】

题目描述

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;
}