最近公共祖先LCA算法——倍增法实现

最近公共祖先LCA算法——倍增法实现

一、介绍

什么是最近公共祖先？权威定义：对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。

简而言之：在一棵没有环的树上，两个节点向上追溯，首次相遇的节点位置，就是这两个节点的最近公共祖先

文字不好描述，下面以图来说明：

如图所示，在左图中，节点4和节点6的最近公共祖先是节点1，在右图中，节点6和节点7的最近公共祖先是节点3

二、倍增法的原理

遇到这种问题我们首先想到的是暴力求解，即从节点深度大的节点位置一层一层向上搜索，当两节点的深度相同时，将两节点同时向上移动，直到两节点相遇。当树的深度较小时，这种方法不失为一种较好的方法。但是当树的深度太大时，这种方法就显示力不从心了，时间效率得不到保证。

这种思路是正确的，但是效率不高，那么我们可以在此基础上优化一下算法：

暴力是一层一层向上搜索，那么我们可不可多层多层向上搜索呢？答案是可以的

用图说话：

求节点8和节点3的最近公共祖先，按照常规思路：节点8 => 4 => 2，当节点8和节点3处于同一深度时，再两节点同时向上移动。直至两者相遇。

可不可以直接从节点8跳到节点2呢？换句话说：怎么知道节点2是节点8的间接父节点呢？

我们可以用一个二维数组 fa 来记录每个节点的父节点和间接父节点，例如 fa[i] [j]表示节点 i 的第 2的j次方的父节点

则 fa[8] [0]=4 fa[8] [1]=2 ( fa[8] [2] != 1 ,fa[8] [0]应该表示节点1的直接父节点，因为节点1是根节点，所以没有父节点，我们可以给它初始化为0 )

递推可以得到：
$$fa[i][j]=fa[fa[i][j-1]][j-1]$$
这个有点类似于那个动态规划，以空间换时间

三、具体应用

问题： 求一棵树上任意两个节点的最近公共祖先

输入示例： 第一行输入两个正整数 n ，m。n表示树的节点的个数，m表示树的根节点。 以下n-1行每行输入两个正整数a，b，表示节点a和节点b之间有一条直线。

最后一行输入任意两个正整数，表示任意两个节点

任意构造一棵树：

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

输出示例：

输出两节点的最近公共祖先

节点5与节点6的最近公共祖先是：3

代码示例：

#include<bits/stdc++.h>
using namespace std;
const int NUM = 1e5+1;
// 定义邻接表，用来存放树的每一个节点 
vector<int> arr[NUM]; 
// 记录每一个节点的深度 
int depth[NUM]={0};
// 树的最大深度 
int maxdepth=0;
// 用来存放每个节点的父亲节点，如fa[i][j]表示节点i的第 2的j次方 个父节点 
int fa[NUM][20];
// n为节点个数，m代表父节点 
int n,m;
void dfs(int root,int father);
void init(int root);
int find(int a,int b);
int main(){
	cin>>n>>m;
	for(int i=1;i<n;i++){
		int a=0,b=0;
		cin>>a>>b;
		arr[a].push_back(b);
		arr[b].push_back(a);
	}
	
	depth[m]=0;
	dfs(m,-1);
	init(m);
	int x=0,y=0;
	cin>>x>>y;
	cout<<"节点"<<x<<"与节点"<<y<<"的最近公共祖先是："<<find(x,y)<<endl;
	return 0;
}
// 深搜树的最大深度 
//root表示当前节点，father表示当前节点的直接父节点 
void dfs(int root,int father){ 
	for(int i=0;i<arr[root].size();i++){
		if(arr[root][i]==father){
			continue;
		}
		// 给每个节点的深度赋值 
		depth[arr[root][i]]=depth[root]+1;
		maxdepth=max(maxdepth,depth[arr[root][i]]);
		fa[arr[root][i]][0]=root;
		dfs(arr[root][i],root);
	} 
}
// 初始化fa数组 
void init(int root){
	for(int i=0;i<20;i++){
		fa[root][0]=0;
	}
	
	for(int i=1;i<=maxdepth;i++){
		for(int j=1;j<=n;j++){
			if(j==root){
				continue;
			}
			fa[j][i]=fa[fa[j][i-1]][i-1];
		}
	}
}
// 寻找两个节点的最近公共祖先 
int find(int a,int b){
	if(depth[a]>depth[b]){
		swap(a,b);
	}
	
	// 如果节点b的深度大于节点a，就将节点b向上移动，直到a与b处于同一深度 
	while(depth[b]>depth[a]){
		int t = (int)(log(depth[b]-depth[a])/log(2));
		b=fa[b][t];
	}
	// 如果a与b相遇，就返回节点a，节点a即是a与b的最近公共祖先 
	if(a==b){
		return a;
	}
	
	// 此时节点a与节点b处于同一深度上，将a与b同时向上移动 
	for(int i=(int)(log(depth[b])/log(2));i>=0;i--){
		// 如果移动后没有相遇，就向上移动 
		if(fa[a][i]!=fa[b][i]){
			a=fa[a][i];
			b=fa[b][i];
		}
	}
	return fa[a][0];
}