P3379 【模板】最近公共祖先（倍增法求LCA）

LCA指的是公共的祖先，即给定数上的两个点x，y求最近的的公共祖先。

1.首先通过DFS预处理各个节点的深度和父亲节点

inline void dfs(int u)
{
    int i;
    for(i=head[u];i!=-1;i=next[i])  
    {  
        if (!deep[to[i]])
        {            
            deep[to[i]] = deep[u]+1;
            p[to[i]][0] = u; //p[x][0]保存x的父节点为u;
            dfs(to[i]);
        }
    }
}

2.初始化各个点的的祖先是谁

void init()
{
    int i,j;
    //p[i][j]表示i结点的第2^j祖先
    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)祖先
}

3.从深度大的节点上升至深度小的节点同层，如果此时两节点相同则返回此节点，即lca。否则，；使用倍增法找到最小深度的

 p[a][j]!=p[b][j],此时，他们的父亲节点p【a】【0】即为lca。

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--;
    //使a，b两点的深度相同
    for(j=i;j>=0;j--)
        if(deep[a]-(1<<j)>=deep[b])
            a=p[a][j];
    if(a==b)return a;//一个节点是另一个节点祖先的情况
    //倍增法，每次向上进深度2^j，找到最近公共祖先的子结点
    for(j=i;j>=0;j--)
    {
        if(p[a][j]!=-1&&p[a][j]!=p[b][j])
        {
            a=p[a][j];
            b=p[b][j];
        }
    }
    return p[a][0];
}

例题连接：https://www.luogu.org/problemnew/show/P3379

题目描述

如题，给定一棵有根多叉树，请求出指定两个点直接最近的公共祖先。

输入输出格式

输入格式：

 

第一行包含三个正整数N、M、S，分别表示树的结点个数、询问的个数和树根结点的序号。

接下来N-1行每行包含两个正整数x、y，表示x结点和y结点之间有一条直接连接的边（数据保证可以构成树）。

接下来M行每行包含两个正整数a、b，表示询问a结点和b结点的最近公共祖先。

 

输出格式：

 

输出包含M行，每行包含一个正整数，依次为每一个询问的结果。

 

输入输出样例

输入样例#1： 复制

5 5 4
3 1
2 4
5 1
1 4
2 4
3 2
3 5
1 2
4 5

输出样例#1： 复制

4
4
1
4
4

说明

时空限制：1000ms,128M

数据规模：

对于30%的数据：N<=10，M<=10

对于70%的数据：N<=10000，M<=10000

对于100%的数据：N<=500000，M<=500000

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int maxn = 500001;
int n, m, cnt, s;
int next[2 * maxn], to[2 * maxn], head[2 * maxn], deep[maxn], p[maxn][21];
void add(int x,int y)
{
    to[cnt]=y;///边所连接的点
    next[cnt]=head[x];///在x的邻接表这个栈的顶部加入一条边（头插法）
    head[x]=cnt++;///cnt为加入边编号，加入后更新head，使得head记录邻接表栈顶边的编号
}
///预处理树的深度和祖先节点
inline void dfs(int i)
{
    int j;
    for(j=head[i];j!=-1;j=next[j])
    {
        if(!deep[to[j]])
        {
            deep[to[j]]=deep[i]+1;
            p[to[j]][0]=i;
            dfs(to[j]);
        }
    }
}
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 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;///其中同一个为另一个祖先的情况
     ///倍增法，每次向上进深度2^j，找到最近公共祖先的子结点
    for(j=i;j>=0;j--)
    {
        if(p[a][j]!=-1&&p[a][j]!=p[b][j])
        {
            a=p[a][j];
            b=p[b][j];
        }
    }
    return p[a][0];
}



int main()
{
    memset(head,-1,sizeof(head));
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<n;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
        add(b,a);
    }
    deep[s]=1;
    dfs(s);
    init();
    for(int i=1;i<=m;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        printf("%d\n",lca(a,b));
    }
    return 0;
}

参考博客：https://www.cnblogs.com/zhenghaotian/p/6658105.html