倍增LCA

最近公共祖先：

两个节点的第一个公共父节点；

求最近公共祖先：

1. 先用dfs求出各个节点的深度、父节点以及到根节点的距离；
2. 将两个节点中的较深节点的深度调整至于较浅节点相等；
3. 将两个节点的深度同时向上加一至最近公共祖先的子节点；
4. 返回父亲；

倍增法求最近公共祖先：

1. 每个数字都可以分解为若干个二的次方的和（二进制）；
2. 先用dfs求出各个节点的深度、父节点以及到根节点的距离；
3. 将两个节点中的较深节点的深度调整至于较浅节点相等，每次上调i的k次方的深度；
4. 将两个节点的深度同时向上加i的k次方至最近公共祖先的子节点；
5. 返回父亲；

例题：

hdoj 2586 How Far Away题目大意：一个村子里有n个房子，这n个房子用n-1条路连接起来，接下了有m次询问，每次询问两个房子a,b之间的距离是多少。

 

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
using namespace std;

struct edge{
    int to;
    int next;
    int w;
};

edge e[80008];
int p[40004][20]//p[i][j]表示节点i的第2^j次方个祖先
,head[40004],f[40004],dis[40004],deep[40004];
int ne=0;
int n,m;

void add(int a,int b,int c){
    e[++ne].to=b;e[ne].w=c;e[ne].next=head[a];head[a]=ne;
}

void dfs(int k,int fa,int dep){
    int i;
    f[k]=fa; deep[k]=dep;
    for(i=head[k];i!=-1;i=e[i].next){
        int v=e[i].to;
        if(v!=fa){
            dis[v]=dis[k]+e[i].w;
            dfs(v,k,dep+1);
        }
    }
}

void init(){
    int i,j;
    for(j=0;(1<<j)<=n;j++)  
        for(i=1;i<=n;i++)  
            p[i][j]=-1;//初始化
    for(i=1;i<=n;i++)p[i][0]=f[i];//每个节点的第一个祖先即自己的父亲
    for(j=1;(1<<j)<=n;j++)
        for(i=1;i<=n;i++)
            if(p[i][j-1]!=-1)p[i][j]=p[p[i][j-1]][j-1];//i的第2^j祖先就是i的第2^(j-1)祖先的第2^(j-1)祖先 
}

int lca(int a,int b){
    int i,j;
    if(deep[a]<deep[b])swap(a,b);
    for(i=0;(1<<i)<=deep[a];i++);
    i--;
    for(j=i;j>=0;j--)
        if(deep[a]-(1<<j)>=deep[b])a=p[a][j];//调整两节点深度至相同
    if(a==b)return a;
    for(j=i;j>=0;j--){
    //倍增法，每次向上进深度2^j，找到最近公共祖先的子结点  
        if(p[a][j]!=-1&&p[a][j]!=p[b][j]/*防止两节点深度小于最近公共祖先*/){
            a=p[a][j];
            b=p[b][j];
        }
    }
    return f[a];
}

int main(){
    int i,j,a,b,c,T;
    scanf("%d",&T);
    while(T--){
        memset(head,-1,sizeof(head));
        scanf("%d%d",&n,&m);
        for(i=1;i<=n-1;i++){
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,c);
            add(b,a,c);
        }
        dis[1]=0;
        dfs(1,-1,0);//dfs求得每个节点的深度，父节点以及到根节点的距离
        init();
        for(i=1;i<=m;i++){
            scanf("%d%d",&a,&b);
            printf("%d\n",dis[a]+dis[b]-2*dis[lca(a,b)]);//ab间的最短距离是a-->LCA-->b,即dis[a]+dis[b]-2*dis[LCA]
        }
    }
    return 0;
}