倍增LCA（最近公共祖先）算法详解

算是详解吧

算法策略：
比如求x和y的最近公共祖先。
先让深度较大（离根较远）的节点跳到与另一节点相同深度的位置（并不一定是同一个点）。
然后两个节点一起往上跳，跳到他们最近公共祖先的孩子停止。
然后返回结果的父亲节点即可。

倍增需要用到ST表算法（差不多吧）。
没学过ST表看这里

用f[i][j]表示i往上2^j的节点。
比如f[i][0]表示i的父亲，f[i][1]表示i的爷爷……
有了ST表的基础，在此继承状态就显得容易。
f[i][j]表示i往上2^j，那么也就是i往上2^（j-1）再往上2^（j-1）。
所以f[i][j]=f[f[i][j-1]][j-1]。

bin[0]=1;
for(int i=1;i<=20;i++)
    bin[i]=bin[i-1]*2;//bin[i]表示2的i次方。
void dfs(int x, int fa) {
    dep[x]=dep[fa] +1;
    f[x][0]=fa;
    for(int i=1;bin[i]<=dep[x];i++)
        f[x][i]=f[f[x][i-1]][i-1];
    for(int k=last[x];k;k=a[k].next) {
        int y=a[k].y;
        if(y==fa) 
            continue;
        dfs(y,x);
    }
}

然后如何来实现x和y跳到统一深度呢（不一定是同一个点）
那么他们之间肯定是有个高度差（深度差）。
每一个数都可以用2进制来表示。
比如：
5
2进制表示为101
也就是往上跳2^2再往上跳2^0。
然后要注意一点。从大的往小的跳！（什么意思？）
比如说5；
是先跳2^2再跳2^0
而不是先跳2^0再跳2^2（为什么）
如果是先跳2^0的话。那么并不知道要不要跳2^1（因为5-1之后还剩4，有可能会跳）。
如果是先跳2^2的话。那么肯定不用跳2^1（5-4之后剩1，肯定跳不了2^1）。
这就是区别（感觉我并没有说清楚）！
上代码吧：

int Lca(int x, int y) {
    if(dep[x]<dep[y]) 
        swap(x,y);
    for(int i=20;i>=0;i--)
        if(dep[x]-dep[y]>=bin[i])
            x=f[x][i];
    if(x==y) 
        return x;
    for(int i=20;i>=0;i--)
        if(dep[x]>=(1<<i) && f[x][i]!=f[y][i])//要跳到最近公共祖先的孩子节点。如果f[x][i]==f[y][i]的话那么肯定就跳过了！
            x=f[x][i],y=f[y][i];
    return f[x][0];//最后把父亲节点返回即可
}

全代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
struct node {
    int x,y,next;
}a[210000];int len,last[110000];
int dep[110000],f[110000][25];
void ins(int x, int y) {
    a[++len].x=x;a[len].y=y;
    a[len].next=last[x];last[x]=len;
}
int bin[25];
void dfs(int x, int fa) {
    dep[x]=dep[fa] +1;
    f[x][0]=fa;
    for(int i=1;bin[i]<=dep[x];i++)
        f[x][i]=f[f[x][i-1]][i-1];
    for(int k=last[x];k;k=a[k].next) {
        int y=a[k].y;
        if(y==fa) 
            continue;
        dfs(y,x);
    }
}

int Lca(int x, int y) {
    if(dep[x]<dep[y]) 
        swap(x,y);
    for(int i=20;i>=0;i--)
        if(dep[x]-dep[y]>=bin[i])
            x=f[x][i];
    if(x==y) 
        return x;
    for(int i=20;i>=0;i--)
        if(dep[x]>=(1<<i) && f[x][i]!=f[y][i])
            x=f[x][i],y=f[y][i];
    return f[x][0];
}
int main() {
    int n,m;
    bin[0]=1;
    for(int i=1;i<=20;i++)
        bin[i]=bin[i-1]*2;
    scanf("%d%d",&n,&m);
    len=0;memset(last,0,sizeof last);
    for(int i=1;i<n;i++) {
        int x,y;
        scanf("%d%d",&x,&y);
        ins(x,y);ins(y,x);
    }
    dfs(1,0);
    while(m--) {
        int x,y,lca;
        scanf("%d%d",&x,&y);
        lca=Lca(x,y);
        printf("%d\n",lca);
    }
    return 0;
}

LCA目测还是一个很有用的算法。然而倍增的话运用可能更广泛一些。
这篇博客感觉写得不太好，抱歉！