[codevs3287]货车运输

题目描述 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。

在最大生成树上跑LCA
答案即为两点到LCA路径上最小的边
对于最小边的寻找，也可以用倍增的想法完成
记mi[i][j]为i节点到它的第2^j个祖先路径上的最小边
则mi[i][j] = min(mi[i][j-1],mi[fa[i][j-1]][j-1])

#include<cstdio>
#include<algorithm>
#include<iostream>
#define INF 1061109567
using namespace std;
const int MAXN = 100000 + 5;
struct edge
{
    int f,t,v;
}l[MAXN << 1],s[MAXN << 1];
int next[MAXN << 1],head[MAXN],fa[MAXN],f[MAXN][30],deep[MAXN],rank[MAXN],mi[MAXN][26],tot;
void init(int n)
{
    for(int i = 1;i <= n;i ++)
    {
        head[i] = -1;
        fa[i] = i;
    }
}
void build(int f,int t,int v)
{
//  printf("build %d,%d\n",f,t);
    l[++ tot] = (edge){f,t,v};
    next[tot] = head[f];
    head[f] = tot;
}
int n,m,q;
bool cmp(edge a,edge b)
{
    return a.v > b.v;
}
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 merge(int a,int b)
{
    a = find(a);
    b = find(b);
    if(rank[a] > rank[b])swap(a,b);
    fa[a] = b;
    if(rank[a] == rank[b])rank[b] ++;
}
void tree()
{
    for(int i = 1;i <= m;i ++)
    {
        if(!same(s[i].f,s[i].t))
        {
            merge(s[i].f,s[i].t);
            build(s[i].f,s[i].t,s[i].v);
            build(s[i].t,s[i].f,s[i].v);
        }
    }
}
void make_tree(int p,int x)
{
    if(head[x] == -1)return;
    for(int i = 1;i <= 25;i ++)
    {
        f[x][i] = f[f[x][i - 1]][i - 1];
        mi[x][i] = min(mi[x][i - 1],mi[f[x][i - 1]][i - 1]);
    }
    for(int i = head[x];i != -1;i = next[i])
    {
        int t = l[i].t;
        if(t == p)continue;
        f[t][0] = x;
        deep[t] = deep[x] + 1;
        mi[t][0] = l[i].v;
        make_tree(x,t);
    }
}
int get_lca(int a,int b)
{
    if(!same(a,b))return -1;
    if(deep[a] < deep[b])swap(a,b);
    int ans = INF;
    int t = deep[a] - deep[b];
    for(int i = 0;i <= 25;i ++)
    if(t & (1 << i))
    {
        ans = min(ans,mi[a][i]);
        a = f[a][i];
    }
    if(a == b)return ans;
    for(int i = 25;i >= 0;i --)
    if(f[a][i] != f[b][i])
    {
        ans = min(ans,min(mi[a][i],mi[b][i]));
        a = f[a][i];
        b = f[b][i];
    }
    return min(ans,min(mi[a][0],mi[b][0]));
}
int main()
{
    scanf("%d%d",&n,&m);
    init(n);
    int x,y,z;
    for(int i = 1;i <= m;i ++)
    {
        scanf("%d%d%d",&x,&y,&z);
        s[i] = (edge){x,y,z};
    }
    sort(s + 1,s + m + 1,cmp);
    for(int i = 1;i <= m;i ++)
    {
        if(!same(s[i].f,s[i].t))
        {
            merge(s[i].f,s[i].t);
            build(s[i].f,s[i].t,s[i].v);
            build(s[i].t,s[i].f,s[i].v);
        }
    }
    make_tree(1,1);
    scanf("%d",&q);
    for(int i = 1;i <= q;i ++)
    {
        scanf("%d%d",&x,&y);
        printf("%d\n",get_lca(x,y));
    }
    return 0;
}

TIPS:

1、预处理时i的范围不能超过数组范围
e.大小为f[MAXN][25]的数组，则当访问了f[i][25]时，相当于访问了f[i+1][0]，很容易把已经处理好的置0
2、make_tree时访问到已处理的节点，注意是continue不是return；
3、跳到同一深度时，i的枚举顺序任意；寻找lca时，一定要从大到小