LCA 最近公共祖先

LCA 最近公共祖先

一、 什么是最近公共祖先？

二、怎么求LCA

下面附上详细代码（未倍增优化）：

定义：

int n,m; //n个顶点 m条边
vector<int> g[MAXN]; //邻接存树
int depth[MAXN],fa[MAXN];
//depth[x]：x的深度
//fa[x]：x的父亲结点

初始化：

void dfs(int u,int father){//求深度
	//u为当前结点，father为当前结点的父亲节点
	fa[u]=father;
	depth[u]=depth[father]+1;
	//计算深度
	for(int i=0;i<g[u].size();i++){//枚举每一条边
		int v=g[u][i];
		if(v!=father){//如果当前要往下搜的点是父亲结点，就不能搜
			dfs(v,u);//往下接着搜
		}
	}
} 

计算LCA：

int LCA(int x,int y){//计算x和 y的最近公共祖先
	if(depth[x]<depth[y]) swap(x,y);
	//如果x和y不在同一高度，将x和y调到同一高度
	while(depth[x]!=depth[y]){
		x=fa[x];
	}//将x调到y的高度（或深度）

	//这里写的方法和别的地方不太一样
	if(x==y) return x;//此处特判，如果x已经和y相等
	while(fa[x]!=fa[y]){//求最近公共祖先
		x=fa[x];
		y=fa[y];
		//更新x和y，往上搜
	}
	return fa[x];//返回公共祖先fa[x]或fa[y]
}

下面给出完整无注释代码:

#include<iostream>
#include<cstdio>
#include<vector>
#define MAXN 100005
using namespace std;
int n,m;
vector<int> g[MAXN];
int depth[MAXN],fa[MAXN];
void dfs(int u,int father){
	fa[u]=father;
	depth[u]=depth[father]+1;
	for(int i=0;i<g[u].size();i++){
		int v=g[u][i];
		if(v!=father){
			dfs(v,u);
		}
	}
} 
int lca(int x,int y){
	if(depth[x]<depth[y]) swap(x,y);
	while(depth[x]!=depth[y]){
		x=fa[x];
	}
	if(x==y) return x;
	while(fa[x]!=fa[y]){
		x=fa[x];
		y=fa[y];
	}
	return fa[x];
}
int main(){
	scanf("%d",&n);
	for(int i=1,u,v;i<n;i++){
		scanf("%d%d",&u,&v);
		g[u].push_back(v);
		g[v].push_back(u);
	}
	dfs(1,0);
	scanf("%d",&m);
	for(int i=1,x,y;i<=m;i++){
		scanf("%d%d",&x,&y);
		cout<<lca(x,y)<<endl;
	}
	return 0;
}

以上就是LCA无优化代码，接下来可以考虑一下优化

倍增优化

观察此图，可以想到ST算法中的倍增

int fa[MAXN][25];
f[u][x]表示u的2^x倍祖先编号
边界：f[u][0]=father
//考虑用ST算法的动规倍增来优化一下

下面来看一下完整代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#define MAXN 100005
using namespace std;
int n,m;
vector<int> g[MAXN];
int depth[MAXN],fa[MAXN][25];
void dfs(int u,int father){
	fa[u][0]=father;
	//fa[u][0]是边界，u的2^0倍的父亲是father
	depth[u]=depth[father]+1;
	for(int i=0;i<20;i++){//从小到大遍历
		fa[u][i+1]=fa[fa[u][i]][i];
		//状态转移方程:
		//u的2^(i+1)倍祖先=u的父亲的2^i倍的父亲
	}
	for(int i=0;i<g[u].size();i++){//枚举边
		int v=g[u][i];//取边
		if(v!=father){//不能与父亲结点相同，不然就重复搜了
			dfs(v,u);//继续往下搜，v的父亲结点是u
		}
	}
}
int lca(int x,int y){
	//将x与y调到同一高度
	if(depth[x]<depth[y]) swap(x,y);
	//利用二进制分解的思想，从大到小遍历X
	for(int i=20;i>=0;i--){
		if(depth[fa[x][i]]>=depth[y])
			x=fa[x][i];
	}
	if(x==y) return x;//特判
	for(int i=20;i>=0;i--){//依然从大到小遍历
		/*
		这里的if不能写成：
		x!=y，因为这个if第一次一定能过，
		x和y就变成了fa[x][20]与fa[y][20],
		根据状态意义，也就是x,y上面的2^20倍的祖先
		它大概率是0，此后x与y都是0,永远进不了if判断
		*/
		if(fa[x][i]!=fa[y][i]){
			x=fa[x][i];
			y=fa[y][i];
			//往上搜
		}
	}
	return fa[x][0];
}
int main(){
	scanf("%d",&n);
	for(int i=1,u,v;i<n;i++){
		scanf("%d%d",&u,&v);
		//建图
		g[u].push_back(v);
		g[v].push_back(u);
	}
	dfs(1,0);//初始化，计算深度
	scanf("%d",&m);
	for(int i=1,x,y;i<=m;i++){
		scanf("%d%d",&x,&y);
		cout<<lca(x,y)<<endl;
	}
	return 0;
}

以上就是有关LCA的朴素以及倍增优化的一些代码与思路