Noip2013 货车运输 - 生成树 - 倍增

这道题是一类树的瓶颈问题。

题意是求两点路径上的最大的最小边（在图中，两点之间路径不只一条），那么肯定这条最小边存在于最大生成树上。（反证法证明）
同理，若求最小的最大边，这条最小边一定在最小生成树上

因此我们可以将图的问题转化为树上问题。树上两点之间的路径一定经过lca，因此这条路我们可以由lca分成两条链。然后就是更新答案，比较暴力的想法是从两个点分别走到lca，然后更新答案。

这样复杂度有点高，我们想想如何优化暴力走路的过程。
没错，用倍增，把O（n）复杂度的走路优化到O（logn）的倍增跳跃。

核心思想是\(2^{i-1}+2^{i-1} = 2^i\)。这个性质也适用于区间最值，即两个小区间各自的最值再取一次最值就是他们合并之后的大区间的最值。

用g[a][i]表示从a点到根节点的\(2^i\)条边中最小的边权
g[a][0]就是a到他父亲的边权

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
#define debug(x) cerr<<#x<<"="<<x<<endl;
const int INF = 0x7fffffff - 10; 
const int MAXN = 10010, MAXM = 50010;
int n,m,q,tot,ans,last[MAXN],color[MAXN],vis[MAXN],col; 
int fa[MAXN],rk[MAXN],tre[MAXN],num,depth[MAXN],mt; 
int f[MAXN][25], g[MAXN][25];
struct Edge{
    int u,v,w,to;
    Edge(){}
    Edge(int u, int v, int w, int to) : u(u), v(v), w(w), to(to) {}
}e[MAXM*2],teme[MAXM*2];
inline void add(int u, int v, int w) {
    e[++tot] = Edge(u,v,w,last[u]);
    last[u] = tot;
}
bool cmp (Edge a, Edge b) {
    return a.w > b.w;
}
int find(int x) {
    return x == fa[x] ? x : fa[x] = find(fa[x]);
}
bool jud(int a, int b) {
    int aa = find(a);
    int bb = find(b);
    return aa == bb;
}
void merge(int a, int b) {
    int x = find(a);
    int y = find(b);
    fa[x] = y;
}
void mst() {
    for(int i=1; i<=n; i++) {
        fa[i] = i;
    }
    for(int i=1; i<=m; i++) {
        int u = teme[i].u;
        int v = teme[i].v;
        int w = teme[i].w;
        if(find(u)!=find(v)) {
            merge(u,v);
            add(u,v,w);
            add(v,u,w);
        }
    }
}
void dfs(int x) {
    vis[x] = 1;
    for(int i=last[x]; i; i=e[i].to) {
        int v = e[i].v;
        if(vis[v]) continue;
        depth[v] = depth[x] + 1;
        f[v][0] = x;
        g[v][0] = e[i].w;
        dfs(v);
    }
}
int query(int a,int b) {
    ans = INF;
    if(find(a) != find(b)) return -1;
    if(depth[a] > depth[b]) swap(a,b);
    for(int k=mt; k>=0; k--) {
        if(depth[f[b][k]] >= depth[a]) {
            ans = min(ans,g[b][k]);
            b = f[b][k];
        }
    }
    if(a==b) return ans;
    for(int k=mt; k>=0; k--) {
        if(f[a][k] != f[b][k]) {
            ans = min(ans, min(g[a][k], g[b][k]));
            a = f[a][k];
            b = f[b][k];
        }
    }
    ans = min(ans,min(g[a][0],g[b][0]));
    return ans;
}
int main() {
    scanf("%d %d", &n, &m);
    for(int i=1; i<=m; i++) {
        int u,v,w;
        scanf("%d %d %d",&u,&v,&w);
        teme[i].u = u;
        teme[i].v = v;
        teme[i].w = w;
    }
    scanf("%d", &q);
    sort(teme+1,teme+m+1,cmp);
    mst();
    for(int i=1; i<=n; i++) {
        if(!vis[i]) {
            depth[i] = 1;
            dfs(i);
        }
    }
    mt = log(n)/log(2) + 1; // mt一定要开成全局变量
    for(int k=1; k<=mt; k++) {
        for(int i=1; i<=n; i++) {
            f[i][k] = f[f[i][k-1]][k-1];
            g[i][k] = min(g[i][k-1],g[f[i][k-1]][k-1]);
        }
    }
    for(int i=1; i<=q; i++) {
        int c1,c2;
        scanf("%d %d",&c1,&c2);
        printf("%d\n",query(c1,c2));
    }
    return 0;
}

转载于:https://www.cnblogs.com/Zolrk/p/9897017.html