最近公共祖先（LCA）

题目描述

如题，给定一棵有根多叉树，请求出指定两个点直接最近的公共祖先。

输入输出格式

输入格式：

 

第一行包含三个正整数N、M、S，分别表示树的结点个数、询问的个数和树根结点的序号。

接下来N-1行每行包含两个正整数x、y，表示x结点和y结点之间有一条直接连接的边（数据保证可以构成树）。

接下来M行每行包含两个正整数a、b，表示询问a结点和b结点的最近公共祖先。

 

输出格式：

 

输出包含M行，每行包含一个正整数，依次为每一个询问的结果。

 

输入输出样例

输入样例#1： 复制

5 5 4
3 1
2 4
5 1
1 4
2 4
3 2
3 5
1 2
4 5

输出样例#1： 复制

4
4
1
4
4

说明

时空限制：1000ms,128M

数据规模：

对于30%的数据：N<=10，M<=10

对于70%的数据：N<=10000，M<=10000

对于100%的数据：N<=500000，M<=500000

样例说明：

该树结构如下：

第一次询问：2、4的最近公共祖先，故为4。

第二次询问：3、2的最近公共祖先，故为4。

第三次询问：3、5的最近公共祖先，故为1。

第四次询问：1、2的最近公共祖先，故为4。

第五次询问：4、5的最近公共祖先，故为4。

故输出依次为4、4、1、4、4。

 

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn = 500010;
int cnt = 1, n, m, root, a, b;
int head[maxn], depth[maxn], p[maxn][40];
struct Node{
	int to;
	int next;
}node[2 * maxn];
void add(int u, int v) {
	node[cnt].to = v;
	node[cnt].next = head[u];
	head[u] = cnt++;
}

void dfs(int u, int father) {
	depth[u] = depth[father] + 1;
	p[u][0] = father;
	for (int i = 1; (1 << i) <= depth[u]; i++) {
		p[u][i] = p[p[u][i - 1]][i - 1];
	}
	for (int i = head[u]; i; i = node[i].next) {
		int v = node[i].to;
		if (v ^ father) { //如果 v ！= father
			dfs(v, u);
		}
	}
}

int lca(int a, int b) {
	if (depth[a] > depth[b]) { //确保b的深度比a的深度大
		swap(a, b);
	}
	for (int i = 20; i >= 0; i--) { //先将b的深度调到和a的深度一样的位置
		if (depth[b] - depth[a] >= (1 << i)) {
			b = p[b][i];
		}
	}
	if (a == b) return a; //如果俩个点刚和合为一体，那么LCA就是这个点
	for (int i = 20; i >= 0; i--) { // 如果还是俩个点，那么跳跃到LCA下面的一个点
		if (p[a][i] ^ p[b][i]) {
			a = p[a][i];
			b = p[b][i];
		}
	}
	return p[a][0]; //返回LCA
}

int main() {
	cin >> n >> m >> root;
	for (int i = 1; i < n; i++) {
		scanf("%d %d", &a, &b);
		add(a, b);
		add(b, a);
	}
	dfs(root, 0);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &a, &b);
		printf("%d\n", lca(a, b));
	}
	return 0;
}