uva12655 Trucks （MST + ＬＣＡ）

参考链接：http://blog.csdn.net/diary_yang/article/details/16011083

题意：

n个点，必定连通。m条无向边，每条边都有一个权值。s个询问。

每个询问求从l到h的路径中最小权值的边的最大值。

思路：

可以发现答案一定在最大生成树中。假设答案不在最大生成树中，则生成树中必定有某条边(u,v)没有走，而走了不在生成树中其他的若干条边来实现从u到v，由于这些边的权值必定小于等于（u,v）这条边的权值，取他们的最小值只会更小。于是，在最大生成树中必定存在答案。

求完生成树，先做一次dfs，将无根树转为有根树，并记下每个点的深度dep、父亲结点 和 从父亲结点到达该点所经过的边的权值。

        定义如下状态：

        anc[i][0]表示结点i的 父亲，anc[i][1]表示结点i的父亲的父亲， anc[i][j]表示 i的  （父亲）*2^j

        minw[i][0]表示从结点i的父亲到结点i所经过的边的最小权值，  minw[i][j]表示 从anc[i][j]到i的....

       可以在nlogn的时间推出来，然后对每个询问logn处理如下。

       假设求p,q。不妨设dep[p] > dep[q] ，根据之前的预处理，可以让p 通过 anc[p][x]来跳到他的父亲的父亲若干次，直到他与q的深度相同。

      若此时p、q相等，则已找到最近公共祖先，利用过程中的minw[p][x]可以得出答案。

     若还未相等，则p、q同时往上跳，但注意如果某一步跳了之后两者相等，则不跳。这是因为有可能已经跳过头了，到达的不是最近公共祖先，所得答案也会出错。

 

 

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cmath>
#include <algorithm>

using namespace std;

const int maxn = 2e4+5, maxm = 1e5, inf = 1e9;

int u[maxm], v[maxm], w[maxm], r[maxm];
int head[maxn], ec;
int fa[maxn];
int anc[maxn][20], minw[maxn][20], dep[maxn];
struct Edge{
    int v, w, nx;
    Edge(){}
    Edge(int v, int w, int nx): v(v), w(w), nx(nx){}
}e[maxn<<1];

int getFa(int x){
    return fa[x] == x ? x : fa[x] = getFa(fa[x]);
}

bool cmp(const int a, const int b){
    return w[a] > w[b];
}

void add(int u, int v, int w){
    e[ec] = Edge(v, w, head[u]); head[u] = ec++;
}

void addEdge(int u, int v, int w){
    add(u,v,w);add(v,u,w);
}

void init(int n, int m){
    memset(head, -1, sizeof(head));
    ec = 0;
    for(int i = 1; i <= n; i++) fa[i] = i;
    for(int i = 0; i < m; i++) r[i] = i;
}

void mst(int n, int m){
    sort(r,r+m,cmp);
    int cnt = 0;
    for(int i = 0; i < m; i++){
        int e = r[i];
        int f1 = getFa(u[e]);
        int f2 = getFa(v[e]);
        if(f1 != f2){
            fa[f1] = f2;
            addEdge(u[e], v[e], w[e]);
            cnt++;
            if(cnt == n-1) break;
        }
    }
}

void dfs(int u, int f, int d){
    fa[u] = f;
    dep[u] = d;
    for(int i = head[u]; ~i; i = e[i].nx){
        int v = e[i].v;
        if(v == f) continue;
        minw[v][0] = e[i].w;
        dfs(v, u, d+1);
    }
}

void process(int n){
    memset(anc, -1, sizeof(anc));
    for(int i = 1; i <= n; i++){
        anc[i][0] = fa[i];
    }
    minw[1][0] = inf;
    for(int j = 1; (1<<j) <= n; j++)
        for(int i = 1; i <= n; i++)if(~anc[i][j-1]){
            int f = anc[i][j-1];
            anc[i][j] = anc[f][j-1];
            minw[i][j] = min(minw[i][j-1], minw[f][j-1]);
        }
}

int query(int p, int q){

    if(dep[p] < dep[q]) swap(p, q);
    int k = 0;
    while((1<<k) < dep[p]) k++;
    int ans = inf;
    for(int i = k; i >= 0; i--)
        if(~anc[p][i] && dep[anc[p][i]] >= dep[q])
            ans = min(ans, minw[p][i]), p = anc[p][i];
    if(p == q) return ans;
    for(int i = k; i >= 0; i--)
        if(~anc[p][i] && anc[p][i] != anc[q][i]){
            ans = min(ans, minw[p][i]); p = anc[p][i];
            ans = min(ans, minw[q][i]); q = anc[q][i];
        }
    if(p!=q){
        ans = min(ans, minw[p][0]);
        ans = min(ans, minw[q][0]);
    }
    return ans;
}

int main(){
//    freopen("in.txt", "r", stdin);
    int n, m, s;
    while(~scanf("%d%d%d", &n, &m, &s)){
        init(n,m);
        for(int i = 0; i < m; i++) scanf("%d%d%d", u+i, v+i, w+i);
        mst(n,m);
        dfs(1,-1,1);
        process(n);
        for(int i = 0, l, h; i < s; i++){
            scanf("%d%d", &l, &h);
            printf("%d\n", query(l, h));
        }
    }
    return 0;
}