lca最近公共祖先代码及分析（倍增）

祖孙询问

给定一棵包含 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

输入样例：

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

输出样例：

1
0
0
0
2

分析题意我们发现我们需要先建图，然后根据询问逐行给出查询结果

这里先给出在线查询求最近公共祖先的方法，也就是倍增法

倍增法是比一般的暴力查询要快的，其优化原理就是用二进制预处理了所有节点的部分祖先是什么，从而加快了查询速度

预处理阶段我们先从根节点开始处理根节点以上节点的深度和父节点，这里可以用dfs也可以用bfs做

但是用dfs容易爆栈，用bfs更稳定而且不比dfs慢，所以我们选择用bfs来预处理

 开始的时候我们先把所有节点的深度都设置为正无穷，这里就相当于vis数组了，因为除非有无穷多个数据，否则没有节点的深度会是正无穷，所以我们在遍历的时候若是一个点的子节点的深度是正无穷，那么一定说明这个结点没有被遍历过

我们还要把根节点的深度设置为1，其中0号结点的深度设置为0，这里很有用，下面补充

所以我们先将根节点入队，然后遍历根节点所相连的子节点，判断若是没有被遍历过（用深度判断），就将这个点入队，同时更新一下这个点距离为2^0的结点（当然就是父节点啦），之后就从小到大开始搜这个点上面的结点

然后就是查询阶段

我们按照两步来走，第一步先把a和b结点放到同一深度（因为要求最近公共祖先，那么最近的祖先的深度也不会大于深度较小的那个结点的深度）

这里当然要让深度较深的结点往深度较浅的结点跑，这里不妨令a的深度较深

若是判断a跑完后的深度不小于b结点的深度，那么就让a一直跑

最后ab两点一定是在同一深度了，那么b有没有可能恰好就是a的祖先呢？是有可能的，所以还要加上一个判断：若是a和b相同，那么就说明b是a的祖先，直接返回a或b就可

若不满足，就让a和b一起往上跑

但是要注意一点，我们是不能跑多了的，说的明白点就是我们一定可以找到一个节点满足是a和b的公共祖先，譬如根节点，但是这样就不满足是“最近公共祖先”的限制了

所以我们将距离从大到小遍历的时候，若是a和b更新后的祖先相同，那么就不能更新。反之若是a和b更新后的结点不相同，那么就说明还没有找到最近公共祖先，但是肯定更近了！所以是一定要更新的

这样我们遍历完所有的距离之后a和b的上一个节点就一定是a和b的最近公共祖先

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int N = 80010;
int n,m,root;
int h[N],e[N],ne[N],idx;
int dep[N],fa[N][16];
int add(int a,int b)
{
	e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}
int bfs(int root)
{
	queue<int>q;
	memset(dep,0x3f3f3f3f,sizeof dep);
	dep[root] = 1,dep[0] = 0;
	q.push(root);
	
	while(q.size())
	{
		int t = q.front();
		q.pop();
		for(int i=h[t];~i;i=ne[i])
		{
			int j = e[i];
			if(dep[j]>dep[t]+1)
			{
				dep[j] = dep[t]+1;
				q.push(j);                                                    //不要忘记把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(dep[a]<dep[b]) swap(a,b);
	for(int k=15;k>=0;k--) if(dep[fa[a][k]]>=dep[b]) a = fa[a][k];             //注意是a下一步的深度和b的深度作比较 
	if(a==b) return a;
	for(int k=15;k>=0;k--) if(fa[a][k]!=fa[b][k]) {a = fa[a][k],b = fa[b][k];}
	return fa[a][0];
}
int main()
{
	cin>>n;
	memset(h,-1,sizeof h);
	for(int i=1;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;
	for(int i=1;i<=m;i++)
	{
		int a,b;
		cin>>a>>b;
		int t = lca(a,b);
		if(t==a) cout<<1<<endl;
		else if(t==b) cout<<2<<endl;
		else cout<<0<<endl;
	}
	
	return 0;
}

要加油哇！！