LCA（最近公共祖先）的多种实现方法——dfs、倍增

LCA是什么我就不多说了，主要分析下求LCA的方法。

1.普通的dfs

如果节点W是u，v的最近公共祖先的话，那么把两者先弄到同一高度，再把两者同时向上爬，直到相等，那这个节点就是公共祖先。

//LCA normal dfs O(n)for once
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
vector<int> g[100000];
int dep[100000],parent[100000],n;
int root=1;
void dfs(int v,int p,int d){
	parent[v]=p;
	dep[v]=d;
	for(int i=0;i<g[v].size();i++){
		if(g[v][i]!=p){
			dfs(g[v][i],v,d+1);
		}
	}
}
void init(){
	dfs(root,-1,0);//初始化 
}
int lca(int u,int v){
	while(dep[u]>dep[v]) u=parent[u];
	while(dep[v]>dep[u]) v=parent[v];
	while(u!=v){
		u=parent[u];
		v=parent[v];
	}
	return u;
}
int main()
{int u,v;
scanf("%d",&n);//边的条数 
for(int i=0;i<n;i++){
	scanf("%d%d",&u,&v);
	g[u].push_back(v);//利用链接表 
	g[v].push_back(u);
}
init();
int q,w;
scanf("%d%d",&q,&w);
printf("%d",lca(q,w));
	return 0;
}

节点最大深度是n的话，这个算法复杂度是O（n），对于只求一次的情况来说，已经够了。然而出题的人哪会那么善解人意。

2.利用倍增的思想

如果用parent[k][v]表示从v向上走2^k步所到的节点，那么就可以二分搜索。

这其实利用了倍增的思想。

//LCA by dfs+erfen O(log(n))for once
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
vector<int> g[100000];
int parent[20][100000]; 
int dep[100000],root=1;//根节点 
void Swap(int* a,int* b){ 
	int c=*a;
	*a=*b;
	*b=c;
}//交换函数 
void dfs(int v,int p,int d){
	parent[0][v]=p;
	dep[v]=d;
	for(int i=0;i<g[v].size();i++){
		if(g[v][i]!=p){
			dfs(g[v][i],v,d+1);
		}
	}
}
void init(int val){
	dfs(root,-1,0);//初始化 
	for(int k=0;k+1<20;k++){//暂且用20作最大的log（v） 
		for(int v=1;v<=val;v++){//val为最大的节点编号 
			if(parent[k][v]<0) parent[k+1][v]=-1;//向上无路可走 
			else{
				parent[k+1][v]=parent[k][parent[k][v]];//2^k+1=2^k+2^k 
			}
		}
	}
}
int lca(int u,int v){
    if(dep[u]>dep[v]) Swap(&u,&v);//一直认为v更深 
    for(int k=0;k<20;k++){
	/*if(dep[u]<=dep[parent[k][v]]){
			v=parent[k][v];
	}*/
	if((dep[v]-dep[u])>>k&1){
		v=parent[k][v];//走到同一深度 
	}
	}
	if(u==v) return u;//如果已经找到了直接返回 
	//二分搜索 
	for(int k=20;k>=0;k--){
		if(parent[k][v]!=parent[k][u]){
			u=parent[k][u];
			v=parent[k][v];
		}
    }
	return parent[0][u];
}
int main()
{int u,v,n;
scanf("%d",&n);
for(int i=0;i<n;i++){
	scanf("%d%d",&u,&v);
    g[u].push_back(v);
	g[v].push_back(u);
}
init(20);
int q,w;
scanf("%d%d",&q,&w);
printf("%d",lca(q,w));
return 0;
}

这个算法复杂度是log（n）。