倍增法lca 入门——CODE[VS] 4605 LCA

——求lca最近公共祖先，就是要找到树上两个点的祖先节点中，深度最深的相同节点，朴素的解法中，记录每个结点的父节点以及深度，然后对于任意查询，先让深度较深的结点上移至与另外一个结点深度相同，此时若两点相同则找到了lca，若不同，则两点同时一步一步向父节点移动，直至移动到相同的结点。
——倍增法求lca就是在这种朴素的解法上，利用倍增的思想预处理出每个结点上移（2^j ,j=0,1,2,3…）步的祖先节点，从而使朴素算法中的上移找lca的过程的复杂度降低。
——在别人的博客中学习到的这个方法，因此自己来总结一下

倍增法求lca的过程可以简单的分为3步：
(p[i][j]表示i结点上移(2^j)步的祖先节点）
1.dfs求出每个结点的深度dep[i]以及父节点p[i][0]。
2.预处理出所有p[i][j] :( p[i][j]=p[p[i][j-1]][j-1])
3.对于任意两点求lca时，先将深度更深的点移动至深度相同的点。然后同时上移找到lca。（运用倍增的方法上移可以使复杂度为logN级别）

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int maxn=100005;
const int maxe=100005;
struct edge{
    int to,nxt;
}e[maxe];
int head[maxn];
int dep[maxn];
int p[maxn][32];
int tot,root,lastans;
int n,m;
void adde(int u,int v){
    e[tot].to=v;
    e[tot].nxt=head[u];
    head[u]=tot++;
}

void dfs(int u,int depth){
    dep[u]=depth;
    for(int i=head[u];i!=-1;i=e[i].nxt){
        dfs(e[i].to,depth+1);
    }
}

void init(){
    for(int j=1;(1<<j)<n;j++){
        for(int i=1;i<=n;i++){
            p[i][j]=p[p[i][j-1]][j-1];
        }
    }
}

int lca(int u,int v){
    if(dep[u]<dep[v])swap(u,v);
    int dis=dep[u]-dep[v];
    for(int j=0;(1<<j)<=dis;j++){
        if((1<<j)&dis)u=p[u][j];//这里运用了位运算的技巧
    }
    if(u!=v){
        for(int j=log2(n)+1;j>=0;j--){
            if(p[u][j]!=p[v][j]){
                u=p[u][j],v=p[v][j];
            }
        }
        u=p[u][0];
    }
    return u;
}

int main()
{
    int x,y;
    memset(head,-1,sizeof(head));
    tot=0;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&x);
        if(x==0){
            root=i;
            p[i][0]=i;
        }
        else {
            adde(x,i);
            p[i][0]=x;
        }
    }
    dfs(root,0);
    init();
    scanf("%d",&m);
    for(int i=0;i<m;i++){
        scanf("%d%d",&x,&y);
        x=x^lastans;y=y^lastans;
        lastans=lca(x,y);
        printf("%d\n",lastans);
    }

    return 0;
}