LCA-倍增

最近公共祖先倍增算法

---

• 思想：二进制拼凑

• 倍增是向上标记法（O(n)）算法的优化，就是向上寻找带标记的节点时，不再是一步步上去找，而是每次都尽可能跳多一点，减少跳的次数，进而优化时间。

• 我们既然要二进制拼凑，当然要先有各个节点的向上跳2^i次方步后到达节点的信息，这里我们可以有一个fa[i][j] 数组来存从i向上跳2^j次方步后到达的节点，这个处理可以采用递推实现，fa[i][0]为从i向上跳2 ^0，也就是i的父节点,对于大于0的j我们可以换一种方式计算： fa[i][k]从i向上跳2 ^k次方步，可以理解为跳了两次，中间加一个转移状态， 也就是先从i向上跳2 ^(k-1) 次方步，然后再往上跳2 ^(k-1)次方步， 2 ^(k-1) + 2 ^(k-1) = 2*2 ^(k-1) = 2 ^k,也就是在跳到2 ^(k-1)的位置再跳2 ^(k-1)步：
  fa [ i ] [ j ] = fa [fa [ i ] [ j-1 ] ] [ j-1 ]
  
  所以fa[i][j]数组预处理需要nlog(n)时间

• 对于两个要询问关系的节点，我们要让他们先在同一层，然后再一起找最近公共祖先，这时候我们就还需要一个记录每个节点所在层数的数组depth[i]表示i节点所在的层数，我们规定根节点为第一层depth[root]=1,求depth数组我们可以深搜也可以广搜来求，广搜靠谱点，深搜爆栈就不好了，预处理倍增数组，也可以在广搜的时候同步完成。

• 我们对于不在同一层的两个节点，是深度大的跳到深度小的上面去，我们所有节点的深度都是>=1的，所以说跳出去的话depth会等于0，0<所有的节点深度，这也就保证了我们从大到小跳一定可以跳过去，拼凑出所有的步数，当都在同一层时，我们再一起跳，当depth[a]!=depth[b]时，a,b肯定都在他俩的最近公共祖先的下面，我们就让满足这个条件下的a,b不断向上跳，跳出去的话也都是depth=0，就不满足条件，所以说不会跳出去，这样我们返回他们的父节点就是他们的最近公共祖先了
  
  所以查询的时候最多也只会跳Log2(n)次

  这里面bfs时root根节点就无法被初始化了，因为它本身就在这棵树最顶部了，不需要向上移动一步，只需要depth[root]=1就好，depth[0]=0的含义就是一个哨兵，来监视是否跳出根节点，因为后面我们会根据两个点所在的层数来进行跳到同一层，所以当一个数跳出根节点时，fa[a][j]=0,这时候depth[fa[a][j]]=0，的话就可以阻止下一步a=fa[a][j]了，跳出根节点的我们就不变

• 这里我们一直说跳跳跳，那我们到底要跳多少呢，看我们的节点个数，最坏的情况，所有节点都在一条链上，这时候最底端的跳到最上面需要log2(n)步，所以我们跳2^(0—log2(n))肯定能拼凑出来需要跳的确切的步数，比如需要跳1101步，我们从大往小试，先挑1000再100再1就ok了，而且每一个2次方只会用一次。

链接：AcWing_1172

代码

---

#include<bits/stdc++.h>
using namespace std;
const int N=4e4+10,M=N*2;
int n,m;
int h[N],e[M],ne[M],idx;
int depth[N],fa[N][16];
int q[N];
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;//哨兵,就是说如果a跳过后fa[a][j]=0，这时候的depth[fa[a][]j]=0，表示跳出根节点了，不再改变a的位置
	depth[root]=1;
	int hh=0,tt=-1;
	q[++tt]=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)
			{
				depth[j]=depth[t]+1;
				cout<<depth[j]<<endl;
				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--)
	{
		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[b][k])
		{
		//只要跳出他俩的最近公共祖先，fa[a][k]就一直等于fa[b][k]，出了根节点就都等于零
		//没跳出根节点就都是他俩的祖先也是相等
			a=fa[a][k];
			b=fa[b][k];
		}
	}
	return fa[a][0];
}
int main()
{
	scanf("%d",&n);
	int root=0;
	memset(h,-1,sizeof(h));
	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(root);
	scanf("%d",&m);
	while(m--)
	{
		int a,b;
		scanf("%d %d",&a,&b);
		int p=lca(a,b);
		if(p==a) puts("1");
		else if(p==b) puts("2");
		else 
		{
			puts("0");
		}
	}
	
	return 0;
}

---