[NOIP2013]货车运输

题目描述

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

输入输出格式

输入格式：

 

第一行有两个用一个空格隔开的整数 n,m，表示 A 国有 n 座城市和 m 条道路。 

接下来 m 行每行 3 个整数 x,y,z，每两个整数之间用一个空格隔开，表示从 x 号城市到 y 号城市有一条限重为 z 的道路。注意： x 不等于 y ，两座城市之间可能有多条道路 。

接下来一行有一个整数 q，表示有 q 辆货车需要运货。

接下来 q 行，每行两个整数 x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意： x 不等于 y 。

 

输出格式：

 

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

 

最大生成树 + 简单并查集 + LCA

刚看题的时候想了想, 首先想到了LCA和RMQ, 

又想了想, 感觉是RMQ的最小值. 但又仔细想了想, 如果相同的节点有很多遍的话, 怎么办? 想了想应该选择限制最大的边,

后来又仔细一想, 最大生成树! 想了想应该是最大生成树, 因为最大生成树选择的边是尽量大的.

随后就是用树上倍增, 开始没想求LCA的, 想直接求weight就行, weight[x][i]代表了从x到2的i次方辈祖先的承受重量的最小值.

写到哪里发现还是需要LCA.

后来发现这些城市不一定属于一个连通块, 然后突然就蒙了...

又双叒叕发现了之前的并查集可以用...在发现我还需要对所有连通块都进行bfs.

一开始并查集写错了...

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
const int MAXN = 1e4 + 600;
const int MAXM = 5e4 + 600;
const int MAXB = 22;
struct Edge{
    int to, next, limit;
    Edge(){}
    Edge(int to, int next, int limit): to(to), next(next), limit(limit){}
    bool operator<(const Edge & rhs) const{
        return limit < rhs.limit;
    }
} edges[MAXM << 1];
vector<Edge> edgeSet;
int ihead[MAXN];
int faz[MAXN];
int weight[MAXN][MAXB], ancestor[MAXN][MAXB];
int bthPow[MAXB];
int deep[MAXN];
int n, m, q, eCnt;
void init(){
    // union-find initialization
    for(int i = 0; i < MAXN; ++i){
        faz[i] = i;
    }
    memset(deep, -1, sizeof(deep));
    memset(weight, 0x3f3f3f3f, sizeof(weight));
    bthPow[0] = 1;
    for(int i = 1; i < MAXB; ++i){
        bthPow[i] = bthPow[i - 1] << 1;
    }
}
void insert(int u, int v, int limit){
    edges[++eCnt].to = v;
    edges[eCnt].limit = limit;
    edges[eCnt].next = ihead[u];
    ihead[u] = eCnt;
}
int find(int x){
    if(x == faz[x]){
        return x;
    }
    return faz[x] = find(faz[x]);
}
void merge(int x, int y){
    x = find(x);
    y = find(y);
    if(x != y){
        faz[y] = x;
    }
}
void kruskal(){
    for(int i = edgeSet.size() - 1; i > -1; --i){
        Edge t = edgeSet[i];
        int x = find(t.to), y = find(t.next);
        if(x != y){
            merge(x, y);
            insert(t.to, t.next, t.limit);// 这里建边即可
            insert(t.next, t.to, t.limit);
        }
    }
}
void bfs(int v){
    queue<int> q;
    q.push(v);
    deep[v] = 0;
    int u;
    while(!q.empty()){
        v = q.front();
        q.pop();
        for(int i = ihead[v]; i; i = edges[i].next){
            u = edges[i].to;
            if(deep[u] == -1){
                deep[u] = deep[v] + 1;
                weight[u][0] = edges[i].limit;
                ancestor[u][0] = v;
                q.push(u);
            }
        }
    }
    for(int level = 1; level < MAXB; ++level){
        for(int i = 1; i <= n; ++i){
            ancestor[i][level] = ancestor[ancestor[i][level - 1]][level - 1];
        }
    }
    for(int level = 1; level < MAXB; ++level){
        for(int i = 1; i <= n; ++i){
            weight[i][level] = min(weight[i][level - 1], weight[ancestor[i][level - 1]][level - 1]);
        }
    }
}
int lca(int x, int y){
    if(deep[x] < deep[y]){
        swap(x, y);
    }
    for(int i = MAXB - 1; i > -1; --i){
        if(deep[ancestor[x][i]] >= deep[y]){
            x = ancestor[x][i];
        }
    }
    if(x == y){
        return x;
    }
    for(int i = MAXB - 1; i > -1; --i){
        if(ancestor[x][i] != ancestor[y][i]){
            x = ancestor[x][i];
            y = ancestor[y][i];
        }
    }
    return ancestor[x][0];
}
int query(int a, int v){
    int d = deep[v] - deep[a];
    if(d == 0){
        return 0x3f3f3f3f;
    }
    int power = upper_bound(bthPow, bthPow + MAXB, d) - bthPow - 1;
    // 找小于等于d的最大二次幂
    int A = weight[v][power];
    for(int i = MAXB - 1; i > -1; --i){
        if((d & (1 << i)) && i != power){
            v = ancestor[v][i];
        }
    }// 这里就是把v提上去, 使提上去之后的v的2的power辈祖先是a
    int B = weight[v][power];
    return min(A, B);
}
int main(){
    init();

    scanf("%d%d", &n, &m);
    int u, v, limit;
    for(int i = 0; i < m; ++i){
        scanf("%d%d%d", &u, &v, &limit);
        edgeSet.push_back(Edge(u, v, limit));// 这里不要建边
    }
    sort(edgeSet.begin(), edgeSet.end());
    kruskal();
    for(int i = 1; i <= n; ++i){
        if(deep[i] == -1){
    		bfs(i);
        }
    }
    scanf("%d", &q);
    while(q--){
        scanf("%d%d", &u, &v);
        int a = lca(u, v);
        int rst = min(query(a, u), query(a, v));
        if(find(u) != find(v)){
            rst = -1;
        }
        printf("%d\n", rst);
    }
    return 0;
}

写了1小时, 调了2小时...这么长的代码写的很舒服