倍增法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;
}