Noip2013 Day1 T3 货车运输（树上倍增）

题目描述

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。

思路

这道题要求找到两个节点中所有路中 每条路最小权值 的最大值

如果用SPFA暴力的话，只能拿30分（因为每条路都需要松弛操作）

那么我们如果加上最大生成树删去不必要的边的话，就可以优化到60分

那最后如果要拿满分的话只能用倍增了

（如果图是一棵树的话，那树上倍增的效率确实厉害）

还是先用最大生成树删边，用倍增找LCA

找到LCA之后去算LCA间的最小权值

最后能改出来正是不容易（虽然借鉴了题解很多）

代码

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=10010;
const int M=500010;
const int INF=0x7fffffff;
struct node{
    int u,v,w;
    bool operator < (const node &s) const{
        return w>s.w; 
    }// 运算符重载，为了快排 
}e[M];
int fa[N];//父节点 
int n,m,q,num;
int head[N],to[M],v[M],w[M];//邻接表 
int dep[N],vis[N],lca_fa[N][30],min_w[N][30];
void add(int U,int V,int W)
{
    to[++num]=head[U],head[U]=num,v[num]=V,w[num]=W;
    to[++num]=head[V],head[V]=num,v[num]=U,w[num]=W;
}
int find(int x)
{
    if(fa[x]!=x) fa[x]=find(fa[x]);
    return fa[x];
}
void kruskal()
{
    sort(e,e+m);
    for(int i=0;i<=m-1;i++)
     if(find(e[i].u)!=find(e[i].v))
      {
        add(e[i].u,e[i].v,e[i].w);
        fa[find(e[i].u)]=find(e[i].v);
      }
}//最大生成树 
void lca_dfs(int u,int FA,int deep) 
{
    vis[u]=1,lca_fa[u][0]=FA,dep[u]=deep;
    for(int h=head[u],o=v[h];h;o=v[h=to[h]])
    if(o!=FA) min_w[o][0]=w[h],lca_dfs(o,u,deep+1);
}//预处理 
void init()
{
    for(int j=1;j<=20;j++) 
     for(int i=1;i<=N;i++)
      {
        lca_fa[i][j]=lca_fa[lca_fa[i][j-1]][j-1];
        min_w[i][j]=min(min_w[i][j-1],min_w[lca_fa[i][j-1]][j-1]);
      }
} 
int lca(int x,int y)
{
    if(dep[x]<dep[y]) swap(x,y);
    int f=dep[x]-dep[y],ans=INF;
    if(f>0)
    {
        for(int i=0;f;f=f>>1,i++)
        if(f&1)
        {
            ans=min(ans,min_w[x][i]);
            x=lca_fa[x][i];
        }
    }
    if(x==y) return ans;
    for(int i=20;i>=0;i--)
    if(lca_fa[x][i]!=lca_fa[y][i])
    {
        ans=min(ans,min(min_w[x][i],min_w[y][i]));
        x=lca_fa[x][i],y=lca_fa[y][i];
    }

    ans=min(ans,min(min_w[x][0],min_w[y][0]));
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<=m-1;i++) scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
    for(int i=1;i<=n;i++) fa[i]=i;
    kruskal();
    for(int i=1;i<=n;i++)
    if(!vis[i]) lca_dfs(i,0,1);
    init();
    scanf("%d",&q);
    for(int i=1;i<=q;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if(lca(x,y)==INF||lca(x,y)==0) printf("-1\n");
        else printf("%d\n",lca(x,y));
    }
    return 0;
}