货车运输 noip2013 luogu P1967 （最大生成树+倍增LCA）

luogu题目传送门！

首先，题目让我们求每个货车的最大运输量，翻译一下就是求路径上边权最小的边。

利用一下贪心思想可知，所有货车肯定都会尽量往大的边走。

进一步翻译，即为有一些小边货车根本不会走，或者说，我们只用知道点与点之间最大的连通路径就好了。

！！！

那么，我们求一下最大生成树，就可以知道最大连通图了。

然后来到第二步：求出了最大生成树，即树上点与点的路径只有一条，这条路也肯定是符合题目要求的。

那么，如何求出路径上最小的边？
暴力DFS？FLOYD？SPFA？

最快也是O（N＊Ｐ）的复杂度让你通通T掉！

因此，面对如此多的询问，考虑在线维护的做法，不考虑问一次遍历一次的做法。

于是，众神仙便想出了倍增的做法：

在倍增的时候维护一个w， 和倍增的f类似， w应该存储指向w方向的最小边。

每次询问时，快速倍增取min就好了。

#include <bits/stdc++.h>
using namespace std;
#define N 500010
#define INF (~0u>>1)

inline int read(){
    int x = , s = ;
    char c = getchar();
    while(!isdigit(c)){
        if(c == '-')s = -;
        c = getchar();
    }
    while(isdigit(c)){
        x = (x << ) + (x << ) + (c ^ '');
        c = getchar();
    }
    return x * s;
}

struct edge{ // 临时存边
    int u, v, dis;
} e[N];

struct node{
    int u, v, w;
    int next;
} t[N];
int head[N];
int fa[N]; // 并查集
int  n, m;

int bian = ;
inline void add(int u, int v, int w){
    t[++bian].u = u;
    t[bian].v = v;
    t[bian].w = w;
    t[bian].next = head[u];
    head[u] = bian;
    return ;
}

bool cmp(edge a, edge b){
    return a.dis > b.dis;
}

inline int find(int x){
    if(x == fa[x])return fa[x];
    else return fa[x] = find(fa[x]);
}

inline void kruskal(int n, int m){ // 求最大生成树
    sort(e + , e + m + , cmp);
    for(int i = ;i <= n; i++)
        fa[i] = i;   // 并查集初始化
    for(int i = ;i <= m; i++){
        int fau = find(e[i].u), fav = find(e[i].v);
        int u = e[i].u, v = e[i].v;
        if(fau != fav){
            fa[fau] = fav;
            add(u, v, e[i].dis);
            add(v, u, e[i].dis);
        }
    }
    return ;
}

namespace LCA{
    int deth[N], f[N][];
    int w[N][];
    bool vis[N];

    void dfs(int now){
        vis[now] = ;
        for(int i = head[now]; i; i = t[i].next){
            int v = t[i].v, u = t[i].u,dis = t[i].w;
            if(!vis[v]){
                deth[v] = deth[now] + ;
                w[v][] = dis; // w 储存指向v的边权， 在 LCA 初始化时应变成 LCA 路径上的最小值
                f[v][] = now; // f0 即为自己的上一个
                dfs(v);
            }
        }
        return ;
    }

    int lca(int x, int y){
        if(find(x) != find(y))return -; // 两个点不连通
        int ans = INF;
        if(deth[x] > deth[y])swap(x, y);
        for(int i = ; i >= ;i--){
            if(deth[f[y][i]] >= deth[x]){
                ans = min(ans, w[y][i]);
                y = f[y][i]; // 先拉近距离
            }
        }
        if(x == y)return ans;
        for(int i = ;i >= ; i--){//优先跳大的
            if(f[x][i] != f[y][i]){
                ans = min(ans, min(w[x][i], w[y][i])); // 更新
                x = f[x][i];
                y = f[y][i];//上跳
            }
        }
        ans = min(ans, min(w[x][], w[y][])); // 更新
        return ans;
    }

    void main(){
        for(int i = ;i <= n;i++){ // 恶心数据可能不连通
            if(!vis[i]){
                deth[i] = ;
                dfs(i);//第一次储存信息
                w[i][] = INF;// 开头，不可能有 w
                f[i][] = i;// 开头，本不配有 f。 因此存成自己
            }
        }
        for(int i = ;i <= ; i++){
            for(int j = ;j <= n; j++){
                f[j][i] = f[f[j][i-]][i-];
                w[j][i] = min(w[j][i-], w[f[j][i-]][i-]);//LCA初始化, w应保存 LCA路上指向j点方向的最小边
            }
        }
        int q = read();
        for(int i = ;i <= q; i++){
            int x = read(), y = read();
            printf("%d\n", lca(x, y));
        }
        return ;
    }

}

int main(){
    n = read(), m = read();
    for(int i = ;i <= m; i++){
        int x = read(), y = read(), z = read();
        e[i].u = x;
        e[i].v = y;
        e[i].dis = z;//第一次存储
    }
    kruskal(n, m);//求最大生成树
    LCA::main();
    return ;
}