noip2013 货车运输

题目描述 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和最短边权。

代码

#include<cstdio>
#include<cstring> 
#include<algorithm>
#include<iostream>
#define maxm 50010
#define maxn 10100
using namespace std;

int n, m, done_num;
int fi[maxn], p[maxn], f[maxn], d[maxn];
int st[maxn][20], st_min[maxn][20];

struct Edge{
    int u, v, w;
    int next;
}e1[maxm], e[maxm];

bool cmp(Edge a, Edge b) {
    return a.w > b.w;
}

int get_father(int x){
    if(p[x] == x) return x;
    else return p[x] = get_father(p[x]);
}

inline void add_edge1(int u, int v, int w, int x) {
    e1[x].u = u, e1[x].v = v, e1[x].w = w;
}

inline void add_edge2(int u, int v, int w, int x) {
    e[x].u = u, e[x].v = v, e[x].w = w;
    e[x].next = fi[u], fi[u] = x;
}

void build_tree(int u, int fa, int dep) {
    d[u] = dep;
    for(int i = fi[u]; i != -1; i = e[i].next) {
        int v = e[i].v, w= e[i].w;
        if(v != fa) {
            f[v] = u;
            st_min[v][0] = w;
            build_tree(v, u, dep+1);
        }
    }
}

void LCA_maker() {
    for(int i = 1; i <= n; i++) st[i][0] = f[i];
    for(int j = 1; j <= 16; j++)
        for(int i = 1; i <= n; i++) {
            st_min[i][j] = min(st_min[i][j-1], st_min[st[i][j-1]][j-1]);
            st[i][j] = st[st[i][j-1]][j-1];
        }
}

int Do_it(int x, int y) {
    int ans = 1e9+1;
    if(d[x] < d[y]) swap(x, y);
    for(int i = 16; i >= 0; i--)
        if(d[st[x][i]] >= d[y]){
            ans = min(ans, st_min[x][i]);
            x = st[x][i];
        } 
    for(int i = 16; i >= 0; i--)
        if(st[x][i] != st[y][i]) {
            ans = min(ans, min(st_min[x][i], st_min[y][i]));
            x = st[x][i], y = st[y][i];
        }
    if(st[x][0] == y) ans = min(ans, st_min[x][0]);
    else if(x != y) ans = min(ans, min(st_min[x][0], st_min[y][0]));
    return ans;
}

int main() {
    scanf("%d%d", &n, &m);
    memset(st_min, 127, sizeof(st_min));
    for(int i = 1; i <= m; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        add_edge1(u, v, w, i);
    }
    for(int i = 1; i <= n; i++) p[i] = i, fi[i] = -1;
    sort(e1+1, e1+m+1, cmp);
    for(int i = 1; i <= m; i++) {
        int u = e1[i].u, v = e1[i].v, w = e1[i].w;
        int pu = get_father(u), pv = get_father(v);
        if(pu == pv) continue;
        p[pu] = pv;
        done_num++;
        add_edge2(u, v, w, done_num);
        add_edge2(v, u, w, done_num+n);
        if(done_num == n-1) break;
    }
    for(int i = 1; i <= n; i++) if(p[i] == i) build_tree(i, -1, 1);
    LCA_maker();
    int q;
    for(int i = 1; i <= n; i++)
        int w = get_father(i);
    scanf("%d", &q);
    for(int i = 1; i <= q; i++) {
        int x, y;
        scanf("%d%d", &x, &y);
        if(p[x] != p[y]) printf("-1\n");
        else {
            int ans = Do_it(x, y);
            printf("%d\n", ans); 
        }
    }
    return 0;
}