UVA 11354 Bond 邦德 （RMQ，最小瓶颈MST）

题意：

　　n个城市，m条路，每条路有个危险值，要使得从s走到t的危险值最小。回答q个询问，每个询问有s和t，要求输出从s到t最小的危险值。（5万个点，10万条边）

思路：

　　其实要求的是任意点对之间的最小瓶颈路的权值。

　　先对图求一次MST，那么所有的瓶颈路都在上面。但是q<=5万，即使预先求出所有点对，也需要O(n*n)，太大了。如果对于每个询问才来找答案，这又更慢了。所以得优化。

　　优化方案（1）：先求出生成树，对于每次询问的两个点，求一次LCA，两个点到LCA所经过的边其中一条边就是答案。很不幸，如果树很稀疏，树枝又很长，那么每次求LCA相当于O(n)的复杂度。

　　优化方案（2）：鉴于方案（1），要解决的是树枝很长的情况，由于要求的是区间最值，那么类似于RMQ问题了，只是在树上而不是序列中而已。假如将某个点p到其LCA之间的一条链作为一个区间的话，那么这段区间的最值，就是p到(p+LCA)/2与(p+LCA)/2到LCA两个区间的最值再取最值。这又变成了类似于ST算法了。

　　

　　具体做法可以这样：

　　（1）预处理每个节点p到p+1,p+2...直到树根的这段区间的最值，那么得到m[p,p+1]，m[p,p+2]，m[p,p+4]...。大小是以2的幂为单位的。若某个点到树根的距离并不是刚好为2的整数次幂，那么这段放弃掉，因为总有点到树根的距离是恰好满足的，那么必要时，找这个区间即可。

　　（2）在查询时，两节点分别到他们的LCA所经过的边不断更新答案。

　　倍增算法：此代码用于优化求LCA的速度，以及从p到LCA这段区间的最值。保证在任何树的情况下都是O(logn)。

void preprocess(int n)//预处理2的幂次大小的区间内的最值
{
    for(int i=1; i<=n; i++) //初始化，及先记录到父亲的距离
    {
        anc[i][0]=far[i];
        maxcost[i][0]=cost[i][far[i]]; 
        for(int j=1; (1<<j)<n; j++)  
            anc[i][j]=-1;
    }
    for(int j=1; (1<<j)<n; j++) 
    {
        for(int i=1; i<=n; i++ )
        {
            int e=anc[i][j-1];
            if(e>0)
            {
                anc[i][j]=anc[e][j-1];      //将2的j次幂，分成两个2的j-1次来组成。
                maxcost[i][j]=max(maxcost[i][j-1],maxcost[e][j-1]);
            }
        }
    }
}



int query(int p,int q)  //先找LCA，再求答案
{
    int tmp, log, i;
    if(level[p]<level[q])   swap(p,q);//保持p更深一些

    for(log=1; (1<<log)<=level[p]; log++);//统计最深要几层
    --log;
    int ans=-1;
    for(int i=log; i>=0; i--)//将p提到与q同层
    {
        if(level[p]-(1<<i)>=level[q])//这一步关键，只要多于level[q]的部分都会被抹去
        {
            ans=max(ans, maxcost[p][i]);
            p=anc[p][i];
        }
    }

    if(p==q)    return ans;//LCA为q

    for(int i=log; i>=0; i--)//同时往LCA方向更新，直到成为LCA的孩子
    {
        if(anc[p][i]>0 && anc[p][i]!=anc[q][i] )
        {
            ans=max(ans, maxcost[p][i]);
            p=anc[p][i];
            ans=max(ans, maxcost[q][i]);
            q=anc[q][i];
        }
    }
    ans=max(ans, cost[p][far[p]]);//还有一层，别忘了
    ans=max(ans, cost[q][far[q]]);

    return ans;
}

　　

#include <bits/stdc++.h>
#define INF 0x7f7f7f7f
#define pii pair<int,int>
#define LL long long
using namespace std;
const int N=100010;
int a[N], b[N], w[N], seq[N];     //求MST用的
int pre[N], level[N], far[N], maxcost[N][100], anc[N][100];
int vis[N];
vector<int>  vect[N];    //建树时用
map<int,int> cost[N];

int cmp(int a,int b){return w[a]<w[b];}
int find(int x){return pre[x]==x? x: pre[x]=find(pre[x]);}  //并查集



void DFS(int x,int flo)
{
    vis[x]=1;
    level[x]=flo;  //记录在哪一层
    for(int i=0; i<vect[x].size(); i++)
    {
        int t=vect[x][i];
        if(!vis[t])
        {
            far[t]=x;  //用孩子索引父亲
            DFS(t, flo+1);
        }
    }
}

void preprocess(int n)
{
    for(int i=1; i<=n; i++) //对于每个点
    {
        anc[i][0]=far[i];
        maxcost[i][0]=cost[i][far[i]]; //与父亲的距离。
        for(int j=1; (1<<j)<n; j++)    //初始化祖先为-1
            anc[i][j]=-1;
    }
    for(int j=1; (1<<j)<n; j++)     //仅需到n-1即可。
    {
        for(int i=1; i<=n; i++ )
        {
            int e=anc[i][j-1];
            if(e>0)
            {
                anc[i][j]=anc[e][j-1];      //将2的j次幂，分成两个2的j-1次来组成。
                maxcost[i][j]=max(maxcost[i][j-1],maxcost[e][j-1]);
            }
        }
    }
}


int cal(int n,int m)
{
    memset(maxcost, 0, sizeof(maxcost));
    memset(far, 0,   sizeof(far));
    memset(level, 0,  sizeof(level));
    memset(anc, 0x8f, sizeof(anc));
    //kruscal
    for(int i=0; i<=n; i++)
    {
        pre[i]=i;
        cost[i].clear();
        vect[i].clear();
    }
    for(int i=0; i<m; i++)
    {
        int u=find( a[seq[i]] );
        int v=find( b[seq[i]] );
        if(u!=v)
        {
            pre[u]=v;
            vect[a[seq[i]]].push_back(b[seq[i]]);
            vect[b[seq[i]]].push_back(a[seq[i]]);
            cost[a[seq[i]]][b[seq[i]]]=w[seq[i]];   //因为目前还不知道谁是父亲
            cost[b[seq[i]]][a[seq[i]]]=w[seq[i]];
        }
    }
    //dfs
    memset(vis, 0, sizeof(vis));
    DFS(1, 0);
    preprocess(n);
    return 0;
}



int query(int p,int q)  //先找LCA，再求答案
{
    int tmp, log, i;
    if(level[p]<level[q])   swap(p,q);

    for(log=1; (1<<log)<=level[p]; log++);
    --log;
    int ans=-1;
    for(int i=log; i>=0; i--)
    {
        if(level[p]-(1<<i)>=level[q])
        {
            ans=max(ans, maxcost[p][i]);
            p=anc[p][i];
        }
    }

    if(p==q)    return ans;

    for(int i=log; i>=0; i--)
    {
        if(anc[p][i]>0 && anc[p][i]!=anc[q][i] )
        {
            ans=max(ans, maxcost[p][i]);
            p=anc[p][i];
            ans=max(ans, maxcost[q][i]);
            q=anc[q][i];
        }
    }
    ans=max(ans, cost[p][far[p]]);
    ans=max(ans, cost[q][far[q]]);
    return ans;
}

int main()
{
    freopen("input.txt", "r", stdin);
    int n, m, q, x, y, k=0;

    while(~scanf("%d%d",&n,&m))
    {
        if(k!=0)  printf("
");//格式
        k++;
        for(int i=0; i<m; i++)
        {
            seq[i]=i;   //边号
            scanf("%d%d%d", &a[i], &b[i], &w[i]);
        }
        sort(seq, seq+m, cmp);
        cal(n, m);
        scanf("%d",&q);
        for(int i=0; i<q; i++)
        {
            scanf("%d%d",&x,&y);
            printf("%d
", query(x,y));
        }
    }
    return 0;
}