【算法】祖孙询问

题目

给定一棵包含 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 ≤ n , m ≤ 4 × 10^4
1≤每个节点的编号≤4×104

思路 

我们先自己造一组样例，列出表格找出规律。

输入样例
19
1 -1
1 2
1 3
2 4
2 5
3 4
4 7
4 8
6 11
6 12
8 9
8 10
11 13
12 14
9 15
9 16
13 17
13 18
16 19
0

 我们可以看出，fa [ j ] [ 0 ]储存的是点 j 前面第 pow(2,0)个祖先，fa[ j ] [ 1 ]储存的是第pow(2,1)个祖先，fa[ j ] [ 2 ] 储存的是点 j 的第 pow(2,2)个祖先。

 fa数组中包含的值如下：

索引	i = 0	i = 1	i = 2	i = 3
j = 0	0	0	0	0
j = 1	0	0	0	0
j = 2	1	0	0	0
j = 3	1	0	0	0
j = 4	2	1	0	0
j = 5	2	1	0	0
j = 6	3	1	0	0
j = 7	4	2	0	0
j = 8	4	2	0	0
j = 9	8	4	1	0
j = 10	8	4	1	0
j = 11	6	3	0	0
j = 12	6	3	0	0
j = 13	11	6	1	0
j = 14	12	6	1	0
j = 15	9	8	2	0
j = 16	9	8	2	0
j = 17	13	11	3	0
j = 18	13	11	3	0
j = 19	16	9	4	0

        使用宽搜（或深搜）处理数据，将root的层数定为第一层， 将每一个点定位到属于各个点的层次（如上图所示）。fa[ i ][ j ]数组中储存点 i 的往上数第pow(2,j)个祖宗节点。

        这里使用到了一个性质：

        比如数字24,可以用1，2，4，8，9之和表达，其中1~24中所有数字都可以使用（1，2，3，4，8，9）进行组合而成。（这就是lca函数所运用到的性质）

        所以使用这些数字相加，一定可以找到一个点的所有祖先节点。

代码 

#include<bits/stdc++.h>
using namespace std;

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

int n,m;
int h[N],e[M],ne[M],idx;
int depth[N],fa[N][16];// depth储存该点的层数
queue<int> q;

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;// 点root的层数为第一层
    q.push(root);
    while(!q.empty())
    {
        int t = q.front();
        q.pop();
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(depth[j] > depth[t] + 1)
            {
                depth[j] = depth[t] + 1;
                q.push(j);
                fa[j][0] = t;//f[j][0]储存点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;
    for(int k = 15; k >= 0; k --)
    {
        if(fa[a][k] != fa[a][k])
        {
            a = fa[a][k];
            b = fa[b][k];
        }
    }
    return fa[a][0];
}

int main()
{
    cin >> n;
    int root = 0;
    memset(h,-1,sizeof h);
    
    for(int i = 0; i < n; i ++)
    {
        int a,b;
        cin >> a >> b;
        if(b == -1) root = a;
        else add(a,b),add(b,a);
    }
    
    bfs(root);
    
    cin >> m;
    while(m --)
    {
        int a,b;
        cin >> a >> b;
        int p = lca(a,b);
        if(p == a) cout << 1 << endl;
        else if(p == b) cout << 2 << endl;
        else cout << 0 << endl;
    }
    return 0;
}