【NOIP 2013 Day1 T3】货车运输（最大生成树+LCA）

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

输入描述 Input Description
第一行有两个用一个空格隔开的整数 n，m，表示 A 国有 n 座城市和 m 条道路。
接下来 m 行每行 3 个整数 x、y、z，每两个整数之间用一个空格隔开，表示从 x 号城市到 y 号城市有一条限重为 z 的道路。注意：x 不等于 y，两座城市之间可能有多条道路。
接下来一行有一个整数 q，表示有 q 辆货车需要运货。
接下来 q 行，每行两个整数 x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意：x 不等于 y。

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

样例输入 Sample Input
4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3

样例输出 Sample Output
3
-1
3

数据范围及提示 Data Size & Hint
对于 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。

题解：NOIP2013第一天的第三题，比较难的一道题，做法就是先跑一遍最大生成树，然后找两点之间的LCA，输出路径上的最小值。先做一遍最大生成树可以保证两点之间的路径上的最小值最大，然后求两点之间的LCA找路径上的最小值就可以了。
然后这题我在dfs建树的时候打错了，导致儿子的父亲的父亲是儿子mdzz。
PS：可能codevs的数据比较水，所以暴力LCA就过了

2016.10.26：最近学了倍增lca，把这题又做了一遍。刚开始不会找路径上的最小值，就去看了一下黄学长博客233

代码如下：

暴力lca代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXV=11000;
const int MAXE=51000;
int first[MAXV],nxt[MAXE<<1];
int fa[MAXV],fax[MAXV],dis[MAXV],deep[MAXV];//fa用来dfs建树，fax用来跑kruskal
int n,m,q,tot;
struct edge
{
    int from,to,cost;
}es[MAXE<<1],c[MAXE<<1];//c数组记录每条边，es数组记录最大生成树上的边
void init()
{
    memset(first,-1,sizeof(first));
    memset(deep,0,sizeof(deep));
    tot=0;
}
void build(int f,int t,int d)
{
    es[++tot]=(edge){f,t,d};
    nxt[tot]=first[f];
    first[f]=tot;
}
bool cmp(edge a,edge b)
{
    return a.cost>b.cost;
}
int find(int x)
{
    return fax[x]==x?x:fax[x]=find(fax[x]);
}
void dfs(int s)
{
    for(int i=first[s];i!=-1;i=nxt[i])
    {
        int v=es[i].to;
        if(deep[v]==0)//已经dfs过的点不再dfs
        {
            dis[v]=es[i].cost;
            deep[v]=deep[s]+1;
            fa[v]=s;
            dfs(v);
        }
    }
}
int lca(int x,int y)
{
    int minn=0x7fffff;
    if(deep[x]>deep[y]) swap(x,y);
    while(deep[x]!=deep[y])
    {
        if(dis[y]<minn) minn=dis[y];
        y=fa[y];
    }
    while(x!=y)
    {
        if(dis[x]<minn) minn=dis[x];
        if(dis[y]<minn) minn=dis[y];
        x=fa[x];
        y=fa[y];
    }
    return minn;
}
int main()
{
    scanf("%d%d",&n,&m);
    init();
    for(int i=1;i<=n;i++) fax[i]=i;
    for(int i=1;i<=m;i++)
        scanf("%d%d%d",&c[i].from,&c[i].to,&c[i].cost);
    sort(c+1,c+m+1,cmp);
    for(int i=1;i<=m;i++)
    {
        int x=find(c[i].from);
        int y=find(c[i].to);
        if(x!=y)
        {
            fax[x]=y;
            build(c[i].from,c[i].to,c[i].cost);
            build(c[i].to,c[i].from,c[i].cost);//在最大生成树上建边
        }
    }
    for(int i=1;i<=n;i++)
        if(deep[i]==0) dfs(i);//如果还有没dfs到的，继续dfs
    scanf("%d",&q);
    for(int i=1;i<=q;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        if(find(a)!=find(b)) printf("-1\n");
        else printf("%d\n",lca(a,b));
    }
    return 0;
}
/*
5 7
4 3 4440
3 1 22348
1 3 28368
2 4 25086
5 3 6991
4 3 10638
3 1 11106
4
4 5
1 3
5 4
2 5
*/

倍增lca代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXV=110000;
const int MAXE=510000;
int first[MAXV],nxt[MAXE<<1];
int f[MAXV],deep[MAXV];
int fa[MAXV][30],dis[MAXV][30];
//dis数组类似于fa数组，dis[i][j]记录的是i向上跳2^j步经过的路径上的最小值 
int n,m,q,cnt=0,tot=0;
bool used[MAXV];
struct edge
{
    int from,to,cost;
}es[MAXV],ex[MAXE<<1];
void init()
{
    memset(first,-1,sizeof(first));
    memset(dis,63,sizeof(dis));
    for(int i=1;i<=n;i++) f[i]=i;
}
void build(int f,int t,int d)
{
    es[++tot]=(edge){f,t,d};
    nxt[tot]=first[f];
    first[f]=tot;
}
void dfs(int s)
{
    used[s]=1;
    for(int i=1;i<=20;i++)
    {
        if(deep[s]<(1<<i)) break;
        fa[s][i]=fa[fa[s][i-1]][i-1];//初始化fa数组 
        dis[s][i]=min(dis[s][i-1],dis[fa[s][i-1]][i-1]);//dis存的是最小值 
    }
    for(int i=first[s];i!=-1;i=nxt[i])
    {
        int v=es[i].to;
        if(!used[v])
        {
            dis[v][0]=es[i].cost; 
            deep[v]=deep[s]+1;
            fa[v][0]=s;
            //fa[i][j]表示i向上跳2^j步到达的点的编号 
            //fa[i][0]即i的父亲节点 
            dfs(v);
        }
    }
}
int lca(int x,int y)//倍增lca 
{
    if(deep[x]>deep[y]) swap(x,y);
    int tt=deep[y]-deep[x];
    for(int i=0;i<=20;i++)
        if((1<<i)&tt) y=fa[y][i]; 
    for(int i=20;i>=0;i--)//从大往小跳 
        if(fa[x][i]!=fa[y][i])
        {
            y=fa[y][i];
            x=fa[x][i];//能跳直接跳过去 
        }
    if(x==y) return x;
    else return fa[x][0];
}
int ask(int x,int y)
{
    int minn=0x7fffffff;
    int tt=deep[x]-deep[y];
    for(int i=0;i<=20;i++)
        if((1<<i)&tt)
        {
            minn=min(minn,dis[x][i]);//找路径上的最小值 
            x=fa[x][i];
        }
    return minn;
}
bool cmp(edge aa,edge bb)
{
    return aa.cost>bb.cost;
}
int find(int x)
{
    return f[x]==x?x:f[x]=find(f[x]);
}
int main()
{
    scanf("%d%d",&n,&m);
    init();
    for(int i=1;i<=m;i++)
        scanf("%d%d%d",&ex[i].from,&ex[i].to,&ex[i].cost);
    sort(ex+1,ex+m+1,cmp);
    for(int i=1;i<=m;i++)
    {
        int x=find(ex[i].from);
        int y=find(ex[i].to);
        if(x!=y)
        {
            f[x]=y;
            build(ex[i].from,ex[i].to,ex[i].cost);
            build(ex[i].to,ex[i].from,ex[i].cost);
            if(++cnt==n-1) break;
        }
    }
    for(int i=1;i<=n;i++)
        if(!used[i]) dfs(i);
/*  for(int i=1;i<=n;i++)
        printf("%d %d\n",i,fa[i]);*/
    scanf("%d",&q);
    for(int i=1;i<=q;i++)
    {
        int x,y,lcA;
        scanf("%d%d",&x,&y);
        if(find(x)!=find(y)) printf("-1\n");
        else
        {
            lcA=lca(x,y);
            printf("%d\n",min(ask(x,lcA),ask(y,lcA)));
        }
    }
    return 0;
}