倍增法求解LCA 【Leo_Jose】

前置知识

没啥，倍增和LCA的定义这里会有介绍的
不过代码里面用到了链式前向星的存储方法
反正你得会存图你才能做LCA的题

倍增法

算法思路

假设有一个小白兔，想从第0个格子跳到第23个格子，它可以一次性跳到任意一个格子中，但它不知道终点再哪个格子，不过它能够判断它是在终点的前方还是后方还是正好在终点。

因为它不知道终点在哪里，漫无目的地跳肯定是不行的，要想保险只能一格一格地走，但是这样子$O(n)$的时间复杂度又太浪费时间了。

考虑倍增：
让小白兔每次只能跳刚好$2^n$个格子，然后用以下的方式跳

它先尝试跳32个，过了，然后回来，又尝试跳16个，还没到，这个时候它距离终点又23-16=7个格子，它尝试跳8个（因为如果这个时候还跳16个格子的话，就和跳32个格子没区别了，原理：$2^n+2^n=2^{n+1}$），过了，回来尝试跳4个，还没到，距离7-4=3个格子，然后它尝试跳2个格子，还没到，然后它尝试跳1个格子，终于跳到了终点

为什么这样子呢，你会发现，如果你跳两次1格，其实效果是等价于跳1次2格的。那为何不一次性跳2格呢？
如果你跳两次2格，效果是等价于跳一次4格的。那为何不一次性跳4格呢？
。。。
同时，任何一个数都可以表示成为一些2的n次方的数之和的。比如23就是$2^4+2^2+2^1+2^0$四次就可以了，而一个一个地跳就得跳23次

这便是倍增算法了，时间复杂度：$O(\log n)$

倍增法求LCA

LCA

图片来自于这里
如有侵权请联系删除

LCA即Lowest Common Ancestor, 即最近公共祖先
说人话就是树上两个节点共同的祖先之中，离根节点最远的
例如：6号节点的祖先为4,2,1
8号节点的祖先为5,2,1
那么6号节点和8号节点拥有的公共的祖先就是：2,1
其中离根节点最远的是2号节点（1号节点就是根节点，同时根节点是所有节点的公共祖先）

引入

采用暴力方法进行计算：
假设我们要求6和5的LCA
在求解之前先把整个图BFS一边，分个层次

就像这样
我们发现6在第3层，而5在第2层，那么我们就将6往上跳，跳到和5同层，也就是4
然后4和5一起向上跳，跳到了2，重合了，那么2就是6和5的最近公共祖先

这样子的平均时间复杂度为$O(\log n)$，最坏时间复杂度为$O(n)$

想要这个算法的时间复杂度保持在log n是很难得，你得保证树平衡（参见平衡树），如果出题人毒瘤一点，给一个链图，那你就等着$\text{TLE}$吧

那么，我们可以通过倍增来优化这样子的往上找祖先的步骤

倍增法求解LCA

算法思路

进行一个预处理：令f[i][j]为第i个节点的第j个祖先
首先通过倍增将节点i和j的深度变成一样的。
然后倍增找他们两个节点的共同的第$2^k$个祖先

如何预处理f[][]数组呢？
要知道如果一个一个地预处理，就和暴力没区别了
众所周知：$2^{n-1}+2^{n-1}=2^n$
所以f[i][n]=f[f[i][n-1]][n-1]也就是i号节点的第n个父亲就是i号节点的第n-1个父亲的第n-1个父亲，通过这样预处理即可

代码解释

//利用链式前向星进行存图
#include <cstdio>
#include <iostream>
using namespace std;
inline int read()
{
	register int x=0,f=0;
	register char ch=getchar();
	while(ch<'0' || ch>'9')
		f|=ch=='-',ch=getchar();
	while(ch>='0' && ch<='9')
		x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	return f?-x:x;
}
struct edge
{
	int to,nxt;
};
edge e[maxn<<1];
int head[maxn],cnt;
int d[maxn],f[maxn][32],_log[maxn];
inline void add_edge(int from, int to)
{
	cnt++;
	e[cnt].to=to;
	e[cnt].nxt=head[from];
	head[from]=cnt;
}
void init_lg()
{
	for(int i=1;i<=n;i++)
		lg[i]=lg[i-1]+(1<<lg[i-1]==i);
	//这个我也不大好解释，就相当于是lg[2的k次方-1]=k
}
void bfs(int u, int fa)//u代表当前节点，fa代表u的父亲
{
	f[u][0]=fa;//因为u节点上面2^0个点就是u上面的一个点，就是u的父亲
	d[u]=d[fa]+1;//存储每一个节点的深度
	for(int i=1;i<=lg[d[u]];i++)
		f[u][i]=f[f[u][i-1]][i-1];//f[][]数组
	for(int i=head[u];i;i=e[i].nxt)
		if(e[i].to!=fa)//遍历节点u的儿子们
			dfs(e[i].to,u);
			//那么u就是它的儿子们的父亲,e[i].to就是u的儿子
}
void lca(int x, int y)
{
	if(d[x]<d[y])
		swap(x,y);//为了方便我们让x的深度深一点
	while(d[x]>d[y])
		x=f[x][lg[d[x]-d[y]]-1];
	//说人话就是：x变成x的第lg[d[x]-d[y]]-1个父亲
	//也就是x变成x的第2的(d[x]-d[y])次方-1个父亲
	//d[x]-d[y]就是两个节点的深度差
	if(x==y)
		return x;//如果y本身就是x的祖先，那么x在和y深度相同的时候就会重合，直接返回即可
	for(int k=lg[d[x]]-1;k>=0;k--)
		if(f[x][k]!=f[y][k])
			x=f[x][k],y=f[y][k];//一起向上问候祖宗（雾
	return f[x][0];//因为现在x已经变成了x,y的LCA的儿子了，所以返回x的父亲即可
}
int main()
{
	int n,m,s;
	cin>>n>>m>>s;
	for(int i=1;i<=n-1;i++)
	{
		int x,y;
		cin>>x>>y;
		add_edge(x,y);
		add_Edge(y,x);
	}
	init_lg();
	dfs(s,0);//从树根开始，DFS遍历层数（用BFS也行）
	for(int i=1;i<=m;i++)
	{
		int x,y;
		cin>>x>>y;
		cout<<lca(x,y);
	}
}

这就结束了对于LCA的讲解