祖孙询问（倍增算法求LCA）

Description

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

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

Input

第一行一个整数 表示节点个数；

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

第 n + 2 行是一个整数 m ( 1 ≤ m ≤ 4 × 104 ) 表示询问个数；

接下来 m 行，每行两个不同的正整数 x 和 y  ( 1 ≤ x, y ≤ 4 × 104 ) ，表示一个询问。

Output

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

Sample Input

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

Sample Output

1
0
0
0
2

倍增算法求最近公共祖先步骤：
1. 预处理fa[i][j]数组
2. 将低层节点向上移动至与高层节点同层
3. 将两个节点一齐向上移动至最近公共祖先的下一层

细节解释：
1. fa[i][j]表示i节点从自身向上数的第2^j个祖先
当j=0时，f[i][j] = 其父亲节点
当j>0时，因为2^j = 2^(j - 1) + 2^(j - 1)，所以i向上移动2^j次，等于i向上移动2^(j-1)次后再向上移动2^(j-1)次，因此f[i][j] = f[ f[i][j-1] ][ j-1 ]

2.用fa[i][j]实现层次移动
假设当前点a需要向上移动11层，11的二进制表示为1011，因此需要向上移动2^3+2^1+2^0层

for (int k = 15; k >= 0; k -- )
        if (depth[fa[a][k]] >= depth[b])
            a = fa[a][k];

当k=3，k=2，k=1时，条件成立，a最终向上移动了11层；
其它情况下，a向上移动会超出根节点，此时fa[a][k] = 0，我们可以设置一个哨兵：令depth[0] = 0，因此该不等式变成0 >= depth[b]，不成立，所以a被阻止向上移动超出根节点。
而k从大到小遍历是为了保证能刚好凑出需要的层次；若k从小到大遍历，则k=0，k=1，k=2时条件成立，其它情况下a向上移动都会超出根节点。所以a只向上移动了2^0+2^1+2^2 = 7层，显然无法凑够需要的层次。

3.为什么a,b同层后要一齐向上移动至最近公共祖先的下一层，而不是一齐移动至最近公共祖先
答：假设a,b同层后，fa[a][0]为所求LCA。因为for(k=15;k>=0;k–)的移动顺序，当k=1时，f[a][1] == fa[b][1]，而f[a][1]为LCA的上一层，并不是LCA，因此我们需要移动至LCA的下一层，保证结果是LCA，而不是LCA的祖先。

---

完整代码如下：

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

#define N 40020
#define M 80020

int n, t, root;
int depth[N], fa[N][16];
int h[N], e[M], ne[M], idx;
void add(int a, int b) {
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void bfs() {
	memset(depth, 0x3f, sizeof depth);
	depth[0] = 0, depth[root] = 1;
	int q[N*10], hh = 0, tt = 0;
	q[tt++] = root;

	while (hh!=tt) {
		int t = q[hh++];

		for (int i = h[t]; i != -1; i = ne[i]) {
			int j = e[i];
			if (depth[j] > depth[t]) {
				depth[j] = depth[t] + 1;
				q[tt++] = j;
				fa[j][0] = t;
				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--){
        //若fa[a][k]超出根节点,则fa[a][k]=0,又depth[0]=0,因此a被阻止向上移动超过根结点 
		if (depth[fa[a][k]] >= depth[b])
			a = fa[a][k];
    }
	if (a == b)return a;
	for (int k = 15; k >= 0; k--) {
        //若fa[a][k]超出根节点,则fa[a][k]=0,fa[b][k]=0,因此a,b被阻止向上移动超过根结点
		if (fa[a][k] != fa[b][k]) {
			a = fa[a][k];
			b = fa[b][k];
		}
	}
	return fa[a][0];
}

int main() {
	memset(h, -1, sizeof h);

	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		int a, b;
		scanf("%d%d", &a, &b);
		if (b == -1)root = a;
		else { add(a, b); add(b, a); }
	}
	bfs();
	cin >> t;
	while (t--) {
		int a, b;
		scanf("%d%d", &a, &b);
		int ans = lca(a, b);
		if (ans == a)printf("1\n");
		else if (ans == b)printf("2\n");
		else printf("0\n");
	}
	return  0;
}