祖孙询问（最近公共祖先&倍增lca）

题目：https://www.acwing.com/problem/content/1174/

题意：给定一棵包含 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×10^4

题解：倍增lca

#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <unordered_map>
//#include <unordered_set>
//#include <bits/stdc++.h>
//#define int long long
#define pb push_back
#define pii pair<int, int>
#define mpr make_pair
#define ms(a, b) memset((a), (b), sizeof(a))
#define x first
#define y second
typedef long long ll;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
using namespace std;
inline int read() {
    char ch = getchar();
    int s = 0, w = 1;
    while (ch < '0' || ch > '9') {
        if (ch == '-') w = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        s = s * 10 + ch - '0', ch = getchar();
    }
    return s * w;
}

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存每个点的深度，fa[N][16]表示第i个节点
int q[N];//bfs中的队列           //往上跳2^j个步到了哪个节点，0为哨兵，如果为0代表跳出了图，

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;//规定根节点的深度为1
    int hh = 0, tt = 0;
    q[0] = root;
    while (hh <= tt) {
        int t = q[hh++];
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (depth[j] > depth[t] + 1) { //其实不用判，因为是树，必定加1，指向这个点的只有一条边，无回路
                depth[j] = depth[t] + 1;
                q[++tt] = j;//加入队列
                fa[j][0] = t;//往上跳j^0次方步，就是它的父节点
                for (int k = 1; k <= 15; k++) {//暴力跑往上跳2^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--) {
        //跳到同一层，如果fa[a][k]=0，意味着跳出图了，而depth[0]一定小于depth[b]，因为b是个节点，一个有深度
        //所以这样就可以控制a跳到和b同一层
        if (depth[fa[a][k]] >= depth[b]) a = fa[a][k];
    }
    //如果同一层已经是公共祖先了，就返回
    if (a == b) return a;
    //然后两个点同时往上跳，这个时候跳是跳到，最近公共祖先的下一层的节点
    //这样能够保证跳到的是最近公共祖先，而且跳的快，如果俩个点同时一个一个往上跳，确实能保证最近公共祖先
    //但是太慢，如果k从大到小，遍历，但直接跳到公共节点不能保证跳到的是最近公共祖先
    //所以就从大到小遍历，且跳到最后一个不相等的地方，这俩点就是最近公共祖先的下面两个点
    for (int k = 15; k >= 0; k--) {
        //这个点往上跳2^k步，而且不是公共祖先就跳
        if (fa[a][k] != fa[b][k]) {
            a = fa[a][k];
            b = fa[b][k];
        }
    }
    //返回它俩的最近公共祖先
    return fa[a][0];
}
signed main() {
    n = read();
    int root = 0;
    memset(h, -1, sizeof(h));//链式前向星头结点清空
    for (int i = 0; i < n; i++) {
        int a, b;
        a = read(), b = read();
        if (b == -1)
            root = a;
        else
            add(a, b), add(b, a);
    }
    bfs(root);//倍增处理，
    scanf("%d", &m);
    while (m--) {
        int a = read(), b = read();
        int p = lca(a, b);//得到最近公共祖先
        if (p == a)
            puts("1");
        else if (p == b)
            puts("2");
        else
            puts("0");
    }
    return 0;
}