祖孙询问-

祖孙询问

---

题目描述

---

前置知识

最近公共祖先（LCA）是指有根树中距离两个节点最近的公共祖先。祖先是指从当前节点到树根路径上的所有节点。

如下图所示：

$u$和$v$的公共祖先是指一个节点它既是$u$的祖先，又是$v$的祖先。$u$和$v$的最近公共祖先是指距离$u$和$v$最近的祖先。如果$v$是$u$的祖先，那么$u$和$v$的最近公共祖先就是$v$。

如下图所示：

我们可以使用LCA来求解树上任意两点之间的距离。求$u$和$v$这两个之间的距离时，设为$L$，如果$u$和$v$的最近公共祖先为lca，则$u$和$v$之间的距离为$u$到树根的距离$dist[u]$加上$v$到树根的距离$dist[v]$再减去2倍的lca到树根的距离$2\times dist[lca]$。即有：$L=dist[u]+dist[v]-2\times dist[lca]$。

如下图所示：

从图中可以看出$u$到lca的距离加上$v$到lca的距离，其实就是我们想要求的$u$和$v$之间的距离，设$u$到lca的距离$L_1$，设$v$到lca的距离为$L_2$。可知：$dist[u]=L_1+dist[lca]$，所以$L_1=dist[u]-dist[lca]$；$dist[v]=L_2+dist[lca]$，所以$L_2=dist[v]-dist[lca]$。所以$L=L_1+L_2=dist[u]-dist[lca]+dist[v]-dist[lca]=dist[u]+dist[v]-2\times dist[lca]$

树上倍增法

F[i,j]表示$i$的$2^j$辈祖先，即$i$节点向根节点走$2^j$步所到达的那个节点。

$u$节点向上走$2^0$步，则为$u$的父节点$x$，$F[u,0]=x$；$u$节点向上走$2^1$步，到达节点$y$，$F[u,1]=y$；$u$节点向上走$2^2$步，到达节点$z$，$F[u,2]=z$；$u$节点向上走$2^3$步，节点不存在，$F[u,3]=0$；

如下图所示：

F[i,j]表示$i$的$2^j$辈祖先，即$i$节点向根节点走$2^j$步所到达的那个节点。那么该如何走到$F[i,j]$这个节点呢？可以分为两个步骤：

• $i$节点先向根节点走$2^{j-1}$步得到$F[i,j-1]$
• 然后再从$F[i,j-1]$这个节点出发向根节点走$2^{j-1}$步，得到F[F[i,j-1],j-1]，那么此时走到的节点即为$F[i,j-1]$

如下图所示：

递推公式：F[i,j]=F[F[i][j-1],j-1]，$i=1,2,\cdots ,n$，$j=1,2,\cdots ,k$，$2^k\le n$，$k=logn$

树上倍增法的两个关键步骤：

1. 先将两个点跳到同一层
2. 让两个点同时向上跳，一直跳到它们的最近公共祖先的下一层为止

也就是说先让深度大的$y$向上走到与$x$处于同一深度，然后$x,y$一起向上走。但是这里是按照倍增思想走的，而不是一步一步往上走的，因此速度比较快。

现在来思考两个问题：

• 怎么让深度大的$y$向上走与$x$处于同一深度呢？
• $x$和$y$一起向上走，怎么找到最近的公共祖先呢？

先来解决第一个问题：怎么让深度大的$y$向上走与$x$处于同一深度呢？

假设$y$的深度比$x$的深度大，需要$y$向上走到与$x$处于同一深度，$k=3$，则求解过程如下：

• $y$向上走$2^3$步，如果此时到达节点的深度比$x$的深度小（说明跳的太远了，跳到了$x$的上面了），那么什么也不做
• 减小增量，$y$向上走$2^2$步，如果此时到达节点的深度比$x$的深度大（说明此时还处于$x$的下面），则$y$向上移动，令$y=F[y][2]$
• 减小增量，$y$向上走$2^1$步，如果此时到达节点的深度比$x$的深度相等（说明此时它俩处于同一深度），则$y$向上移动，令$y=F[y][1]$
• 减小增量，$y$向上走$2^0$步，如果此时到达节点的深度比$x$的深度小，那么什么也不做。由于上一次$y$已经与$x$处于同一深度了，而这次啥也没做，因此$y$仍然与$x$处于同一深度。

如下图所示：

总结：

按照增量递减的方式，如果到达节点的深度比$x$的深度还要小，则什么也不做；如果到达节点的深度$\ge x$的深度时，则$y$向上移动，令$y=F[y][2]$，一直循环到增量为0，那么最后一定会有$x$和$y$处于同一深度。

再来解决第二个问题：$x$和$y$一起向上走，怎么找到最近的公共祖先呢？

假设$x,y$已经处于同一深度了，现在一起向上走，$k=3$，则其求解过程如下：

• $x$和$y$同时向上走$2^3$步，如果到达的节点相同，说明是公共祖先节点，但是不能保证是最近公共祖先，于是什么也不做
• 减少增量，$x,y$同时向上走$2^2$步，如果此时到达的节点不相同，则说明肯定不是最近公共祖先节点，那么此时$x,y$都要向上移动，令$x=F[x][2]$，$y=F[y][2]$
• 
• 减少增量，$x,y$同时向上走$2^1$步，如果此时到达的节点不同，那么此时$x,y$都要向上移动，令$x=F[x][1]$，$y=F[y][1]$
• 减少增量，$x$和$y$同时向上走$2^0$步，如果到达的节点相同，什么也不做
• 因此经过这么做，那么最终我们一定让$x,y$都处于它俩的最近公共祖先的下一层了。此时$x,y$的父节点就是最近公共祖先节点了，那么最终只需要$x$或者$y$向上走一步就可以到达最近公共祖先了。即最终的$F[x][0]$或者$F[y][0]$就是答案
• 

完整的求解过程如下图所示：

总结：按照增量递减的方式，如果到达的节点相同时，说明是公共祖先，但是不能保证就是最近公共祖先节点，所以什么也不做；如果到达的节点不相同，那么$x,y$同时往上走，一直到增量为0。此时$x,y$的父节点就是最近公共祖先节点了。

问题：为什么碰到$F[x][k]==F[y][k]$时什么都不做，而且为什么此时就是公共祖先而不能是最近公共祖先呢？

如下图所示：

增量从大到小逐渐递减，设$k=2$，那么$F[x][2]=F[y][2]=0$，但是很明显，此时的$0$号节点只是它俩的公共祖先而已，此时我们啥也不做，也就是说$x$和$y$仍然原地踏步，并没有发生跳跃；然后$k$–，此时$k=1$，那么$F[x][1]=F[y][1]=2$，但是很明显，此时的$2$号节点只是它俩的公共祖先而已，此时我们啥也不做，也就是说$x$和$y$仍然原地踏步，并没有发生跳跃；然后$k$–，此时$k=0$，那么$F[x][0]=F[y][0]=4$，注意此时我们可以直观地看出来$4$是它俩的最近公共祖先，但是由于$F[x][0]=F[y][0]$，因此我们也是什么也不做，也就是说$x$和$y$仍然原地踏步，并没有发生跳跃；然后$k$–，此时$k$为-1，退出循环了。那么，我们发现$x$和$y$确实就是在最近公共祖先的下一层！所以最后$x$或者$y$再向上跳一步就到了最近公共祖先节点了，即$F[x][0]$或者$F[y][0]$就是答案了。

---

核心思路

主要就是利用树上倍增法来求解$LCA$，

这里最多有$N=40000$个节点，那么$2^k\le 40000$，所以$k\le 16$。也就是说我们要给这个F[N][]数组的第二维开的大小应该是$16$，即有$16$位二进制。

还有就是我们用$depth[0]=0$来当作哨兵，它有什么用处呢？假设从$i$开始跳$2^j$步，那么有可能此时已经跳出了整棵树的根节点，那么fa[fa[j][k-1]][k-1]=0，那么到达的那个虚无节点$fa[i][j]=0$，于是$depth[fa[i][j]]=depth[0]=0$。

如何理解处理超过根节点呢？

举个栗子：

因为我们没有对根节点$fa[1][0]$赋值，所以它使用的是全局变量，于是$fa[1][0]=0$。可以知道，$fa[2][0]=1$。假设从$2$节点跳了$2^1$步，那么就会跳出根节点，此时的处理是这样的：$fa[2][1]=fa[fa[2][0]][0]=fa[1][0]=0$，那么$depth[fa[1][0]=depth[0]$，但是此时$depth[0]$还没有定义，那么我们可以给它定义为0，此时就可以表示跳出了根节点了。

还有个细节要注意，我们是让深度更大的先往上跳到与深度较小的节点处于同一层。我们不妨假设$a$是深度较大的，$b$是深度较小的，那么如果$depth(a)<depth(b)$，则交换，也就是说必须保证$a$的深度是$\ge b$的深度，然后对$a$往上跳。

---

代码

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
//对于树来说 有n个顶点 则有n-1条边  
//由于题目说了是无向边,所以最多有2(n-1)条边
const int N=40010,M=N*2;
int n,m;
int h[N],e[M],ne[M],idx;
//记录每个节点的在树中的深度
int depth[N];
//fa[i][j]表示从i节点出发跳2^j步后所到达的节点
int fa[N][16];
//宽搜的队列
int q[N];
void add(int a,int b)
{
    e[idx]=b;
    ne[idx]=h[a];
    h[a]=idx++;
}
//采用bfs,在构建这棵有根树的过程中,预处理出fa[i][j],预处理的时间复杂度是nlogn
void bfs(int root)
{
    //初始化深度为无穷大
    memset(depth,0x3f,sizeof depth);
    //由于已知了q[0]是根节点  所以这里直接让tt=0了
    int hh=0,tt=0;
    q[0]=root;
    //哨兵 如果跳超过了根节点,那么就设那些超过根节点的虚无节点的深度为0
    depth[0]=0;
    //根节点的深度为1
    depth[root]=1;
    //进行宽搜
    while(hh<=tt)
    {
        int t=q[hh++];//取出队头元素
        //遍历t的所有邻接点
        for(int i=h[t];~i;i=ne[i])
        {
            int j=e[i];//取出t的邻接点j
            //说明j还没有倍搜索过
            if(depth[j]>depth[t]+1)
            {
                //更新顶点j的深度
                depth[j]=depth[t]+1;
                //将j加入队列中
                q[++tt]=j;
                //由于赋值后depth[j]=depth[t]+1 说明j的深度大于t的深度
                //那么从j出发跳2^0步后,到达的节点就是t
                fa[j][0]=t;
                //上面已经处理了从j出发跳2^0步了
                //这里是处理从j出发跳2^1,2^2,...,2^15步所能到达的节点
                for(int k=1;k<=15;k++)
                    fa[j][k]=fa[fa[j][k-1]][k-1];
            }
        }
    }
}
//树上倍增法求出顶点a和顶点b的最近公共祖先
int LCA(int a,int b)
{
    //约定顶点a的深度必须>=顶点b的深度,否则就要交换
    if(depth[a]<depth[b])
        swap(a,b);
    //让深度较大的顶点a先往上跳到与深度较小的顶点b处于同一层(有可能a跳到了b身上)
    for(int k=15;k>=0;k--)
    {
        int tmp=fa[a][k];
        //此时跳到了tmp这个节点 如果这节点的深度>=顶点b的深度
        //说明tmp这个节点还没有跳超过顶点b这一层   那么则让a跳到tmp这个节点
        if(depth[tmp]>=depth[b])
            a=tmp;
    }
    //这里说明a跳到了b身上 此时两个重合 最近公共祖先就是a或者b
    if(a==b)
        return a;
    //如果能到这里,就说明a跳到了与b处于同一层
    //那么此时让a和b同时往上跳
    for(int k=15;k>=0;k--)
    {
        //说明它俩跳到的顶点不相同,那么不是公共祖先,则必然不可能是LCA
        if(fa[a][k]!=fa[b][k])
        {
            //让a跳到fa[a][k]这个顶点
            a=fa[a][k];
            //让b跳到fa[b][k]这个顶点
            b=fa[b][k];
        }
    } 
    //退出循环后,a和b一定是跳到了它俩的最近公共祖先节点的下一层
    //那么此时它俩再向上跳2^0=1步就可以找到LCA了
    //因此最终返回 fa[a][0] 或者 fa[b][0]  都是可以的
    return fa[a][0];      
}
int main()
{
    memset(h,-1,sizeof h);
    //整棵树的根节点
    int root=0;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        //根据题目意思,如果b为-1,那么a就是整棵树的根节点
        if(b==-1)
            root=a;
        else
        {
            //建立无向边
            add(a,b);
            add(b,a);
        }    
    }
    //在构建这棵有根树的过程中,预处理出fa[i][j]
    bfs(root);
    scanf("%d",&m);
    //处理m个询问
    while(m--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        //找到顶点a和顶点b的最近公共祖先
        int p=LCA(a,b);
        //如果a是它俩的最近公共祖先
        if(p==a)
            puts("1");
        //如果b是它俩的最近公共祖先    
        else if(p==b)
            puts("2");
        else
            puts("0");        
    }
    return 0;
}

---