浅谈LCA（倍增）

LCA是啥呢  在一棵树当中 lca表示的是两个节点最近公共祖先， 大家看这课树哈节点5 ，3的lca就是1，13和11的LCA就是6。节点8,12的lca就是8，那么我们如何通过被增来实现LCA呢。

首先请大家认真看下面的分析。

depth[x],表示x节点的深度。

大家看下这个数组 grand[x][i] ,这个数组表示标号为x节点向上跳2^i步的节点。例如grand[5][0]=2，因为5这个节点向上跳2^0次方个就是2，当然所有节点向上跳一个就是他的父亲节点，

得到grand[x][0]=他的爸爸

那grand[x][1]=什么呢？等于grand[grand[x][0]][0];

既grand[x][i]=grand[grand[x][i-1]][i-1],为什么呢，2^4=2^3+2^3,表示 x向上跳2的i次的节点=x向上跳i-1次方的这个节点向上跳i-1次方，有点绕口。例如 grand[13][2]=grand[6][2]=g[g[rand][i-1]][i-1];

有了这个预处理那我们是不是可以得到每一个节点向上跳i格呢，然后就是i的取值范围为1<=i<=log2(n),向下取整n表示节点个数，也就是说grand[x][log2(n)]就至少可以跳到根节点甚至上面，当然上面啥都没有。

现在有了这些预处理。我下面是用dfs实现的预处理；

就看如何实现LCA了吧，

首先，让X,Y在同一深度上。在大多数情况下，查询给你的两个点X和Y它们的深度是不同的。但是，如果两点的深度相同，我们就可以实现两个点同时倍增比较何时祖先相同。所以，第一步是使X,Y中深度较深的点往上移动直到与另一个点深度相同。当然，点的移动也可以用倍增完成。

然后，当两点深度相同后，同时向上倍增两个点，当它们祖先刚好相同时，这个祖先就是它们的LCA

来自大佬的理解

vector 

#include<bits/stdc++.h>
#include <string.h>
#include <algorithm>
#include <algorithm>
#define ms(a,i) memset(a,i,sizeof(a))
using namespace std;
int anc[500005][25];
int fa[500005];
vector <int> tree[500005];
int deep[500005];
int n,m,s;
int maxlog;
void dfs(int x)
{
    anc[x][0]=fa[x];
    for (int i=1;i<=maxlog;i++)
    {
        anc[x][i]=anc[anc[x][i-1]][i-1];//倍增思想的体现。不妨在纸上试着画一棵树，脑补一下QWQ
    }

    for (int i=0;i<tree[x].size();i++)
    {
        if (tree[x][i]!=fa[x])
        {
            int y=tree[x][i];
            fa[y]=x;//记录父亲节点
            deep[y]=deep[x]+1;//记录深度
            dfs(y);
        }
    }
}
int lca(int x,int y)
{
    if (deep[x]<deep[y]) swap(x,y);//我们希望X是较深的点。

    for (int i=maxlog;i>=0;i--)//这个循环在完成第一步。
    {
        if (deep[y]<=deep[anc[x][i]]) //不可以丢掉“=“哦Q^Q
        {
            x=anc[x][i];
        }
    }

    if (x==y) return x;//如果Y是X的祖先，就可以直接返回结果了。

    for (int i=maxlog;i>=0;i--)
    {
        if (anc[x][i]!=anc[y][i]) //第二步。
        {
            x=anc[x][i];
            y=anc[y][i];
        }
    }

    return anc[x][0];//注意第二步IF语句的条件。
}
int main()
{

    scanf("%d%d%d",&n,&m,&s);
    maxlog=log(n)/log(2);
    for(int i=1; i<=n-1; i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        tree[u].push_back(v);
        tree[v].push_back(u);
    }
    fa[s]=s;
    dfs(s);
    anc[s][0]=s;
    for(int i=1; i<=m; i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        int ans=lca(a,b);
        printf("%d\n",ans);//在线回答
    }
    return 0;
}

邻接表

#include<bits/stdc++.h>
#include <string.h>
#include <algorithm>
#include <algorithm>
#define ms(a,i) memset(a,i,sizeof(a))
using namespace std;
int n,m,s;
int anc[500010][20],deep[500010];
struct E
{
    int to,next;
} tree[1000010];
int head[500010],cnt;
void init()
{
    ms(head,-1);
    cnt=0;
}
void add(int u,int v)
{
    tree[cnt].to=v;
    tree[cnt].next=head[u];
    head[u]=cnt++;
}

void dfs(int now,int fa)    //处理出深度和父亲
{
    
            
    for(int i=head[now]; ~i; i=tree[i].next)
    {
        if(tree[i].to!=fa)
        {
            deep[tree[i].to]=deep[now]+1;
            dfs(tree[i].to,now);
            anc[tree[i].to][0]=now;
        }
    }

}

void ready()  //处理出各路祖先
{
    for(int j=1; (1<<j)<=n; j++)
        for(int i=1; i<=n; i++)
            anc[i][j]=anc[anc[i][j-1]][j-1];//原理是爷爷是爸爸的爸爸

}

int lca(int x,int y)
{
    if(deep[x]<deep[y])swap(x,y);//默认x深，否则交换，方便处理
    int maxlog=log(n)/log(2);
    for(int i=maxlog; i>=0; i--)
        if(deep[x]-(1<<i)>=deep[y])
            x=anc[x][i];      //判断看能否直接返回
    if(x==y)return x;

    for(int i=maxlog; i>=0; i--)
        if(anc[x][i]!=anc[y][i])
        {
            x=anc[x][i];
            y=anc[y][i];
        }

    return anc[x][0];//返回父亲
}
int main()
{
    init();
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1; i<=n-1; i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        add(u,v);
        add(v,u);
    }
    dfs(s,s);
    ready();
    anc[s][0]=s;
    for(int i=1; i<=m; i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        int ans=lca(a,b);
        printf("%d\n",ans);//在线回答
    }
    return 0;
}