LCA(倍增法) - 祖孙询问 - AcWing 1172

LCA(倍增法) - 祖孙询问 - AcWing 1172

给定一棵包含 n 个节点的有根无向树，节点编号互不相同，但不一定是 1∼n。

有 m 个询问，每个询问给出了一对节点的编号 x 和 y，询问 x 与 y 的祖孙关系。

输入格式

输入第一行包括一个整数 表示节点个数；

接下来 n 行每行一对整数 a 和 b，表示 a 和 b 之间有一条无向边。如果 b 是 −1，那么 a 就是树的根；

第 n+2 行是一个整数 m 表示询问个数；

接下来 m 行，每行两个不同的正整数 x 和 y，表示一个询问。

输出格式

对于每一个询问，若 x 是 y 的祖先则输出 1，若 y 是 x 的祖先则输出 2，否则输出 0。

数据范围

$1\le n,m\le 4\times 10^4,1\le 每个节点的编号\le 4\times 10^4$

输入样例：

10
234 -1
12 234
13 234
14 234
15 234
16 234
17 234
18 234
19 234
233 19
5
234 233
233 12
233 13
233 15
233 19

输出样例：

1
0
0
0
2

---

分析：

$LCA模板题。$

倍增LCA步骤：

$目标：求树上a点和b点的最近公共祖先。我们默认a点层次比b点层次要深。$

$fa[i][k]：表示从i号点向上的第2^k个祖先，depth[i]表示i号点所在的深度。$

$①、从a点先向上移动到b点的同一层次。$

$②、a点和b点共同移动到最近公共祖先的下一层，即判断fa[a][k]=fa[b][k]是否成立，若不成立就向上。$

$③、返回fa[a][0]，即最近公共祖先。$

说明：

$①、为什么要先移动到同一层？$

$因为最终a和b都要移动到祖先的下一层，所以为了方便它们同步移动，先将层次较深的a点移动到b所在层次。$

$②、为什么要移动到最近公共祖先的下一层，而不是直接移动到最近公共祖先？$

$因为a，b至少有一个公共祖先，根节点。若通过倍增的思想得到它们的祖先相等，则不能确定是否为最近的。$

预处理：

$在做倍增LCA之前，我们需要预处理fa数组和depth数组。$

$主要是fa数组，仍然是倍增的思想。$

$从i点向上第2^k个祖先，可由i向上的第2^{k-1}个祖先再向上2^{k-1}个点得到。$

$即fa[i][k]=fa[fa[i][k-1]][k-1]。$

$于是我们可以通过递推的方式求得fa数组。$

$这里用bfs来预处理这两个数组。$

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<iostream>

using namespace std;

const int N=40010, M=N*2;

int n,m;
int e[M],ne[M],h[N],idx;
int fa[N][16],depth[N];

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

void bfs(int root)
{
    memset(depth,0x3f,sizeof depth);
    
    depth[0]=0;//哨兵
    depth[root]=1;
    queue<int> Q;
    Q.push(root);
    
    while(Q.size())
    {
        int u=Q.front();
        Q.pop();
        
        for(int i=h[u];~i;i=ne[i])
        {
            int j=e[i];
            if(depth[j]>depth[u]+1)
            {
                depth[j]=depth[u]+1;
                fa[j][0]=u;
                Q.push(j);
                for(int k=1;k<=15;k++)
                    fa[j][k]=fa[fa[j][k-1]][k-1];            
            }
        }
    }
}

int lca(int a,int b)
{
    if(depth[a]<depth[b]) swap(a,b);
    
    for(int k=15;k>=0;k--)
        if(depth[fa[a][k]]>=depth[b])
            a=fa[a][k];
            
    if(a==b) return a;   //b就是a的祖先
    
    for(int k=15;k>=0;k--)
        if(fa[a][k]!=fa[b][k])
            a=fa[a][k],b=fa[b][k];
            
    return fa[a][0];
}

int main()
{
    scanf("%d",&n);
    
    memset(h,-1,sizeof h);
    int a,b,root=0;
    for(int i=0;i<n;i++)
    {
        scanf("%d%d",&a,&b);
        if(b==-1) root=a;
        else add(a,b),add(b,a);
    }
    
    bfs(root);
    
    scanf("%d",&m);
    for(int i=0;i<m;i++)
    {
        scanf("%d%d",&a,&b);
        int p=lca(a,b);
        if(p==a) puts("1");
        else if(p==b) puts("2");
        else puts("0");
    }
    
    return 0;
}