最近公共祖先之LCA(知识整理+板子总结)

思路来源

《挑战程序竞赛》（倍增+欧拉序）

『图论』LCA 最近公共祖先_小坏蛋_千千的博客-优快云博客（清晰的离线Tarjan）

算法

一、倍增（在线O(nlogn)预处理，O(logn)查询）

#include<bits/stdc++.h> 
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define pb push_back
const int N=1e5+10,M=18;
const int INF=0x3f3f3f3f;
 
int n,m,u,v;
int dep[N],f[N][M];
int d[N];
vector<int>E[N];
 
void dfs(int u,int fa){
	for(auto &v:E[u]){
		if(v==fa)continue;
		dep[v]=dep[u]+1;
		f[v][0]=u;
        for(int i=1;i<18;++i){
            f[v][i]=f[f[v][i-1]][i-1];
        }
		dfs(v,u);
	}
}
int lca(int x,int y){
	if(dep[x]<dep[y])swap(x,y);
	int d=dep[x]-dep[y];
	for(int i=17;i>=0;--i)
	if(d>>i&1)x=f[x][i];
	if(x==y)return x;
	for(int i=17;i>=0;--i){
		if(f[x][i]!=f[y][i])
		x=f[x][i],y=f[y][i];
	}
	return f[x][0];
}
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<n;++i){
		scanf("%d%d",&u,&v);
		E[v].pb(u);E[u].pb(v);
	}
	dfs(1,-1);
    return 0;
} 

二、欧拉序+RMQ（在线O(nlogn)预处理，O(logn)查询）

以poj1330Nearest Common Ancestors为例

预处理欧拉序dfn[]，id[i]用来记录dfs序中第一次访问节点i的时间戳

不妨id[u]<id[v]，那么lca(u,v)=dfn[[id[u],id[v]中dep[j]值最小的j]

ST表里存按dep[]数组存最小值的下标即可

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cmath>
using namespace std;
const int maxn=2e4+10;
vector<int>E[maxn];
int T,n,u,v;
int dfn[2*maxn],tot;//欧拉序 
int dep[2*maxn];//各顶点深度 
int id[maxn];//各顶点第一次出现下标 
int dp[maxn][20];
bool vis[maxn];
void dfs(int u,int fa,int d)
{
	id[u]=++tot;
	dfn[tot]=u;
	dep[tot]=d;
	for(int i=0;i<E[u].size();++i)
	{
		int v=E[u][i];
		if(v==fa)continue;
		dfs(v,u,d+1);
		dfn[++tot]=u;
		dep[tot]=d;
	}
}
void ST()
{
	for(int i=1;i<=tot;++i)
	dp[i][0]=i;//存的是最小值的下标 
	for(int len=1;(1<<len)<=tot;++len)
	{
		for(int l=1;l+(1<<len)-1<=tot;++l)
		{
			if(dep[dp[l][len-1]]<dep[dp[l+(1<<(len-1))][len-1]])dp[l][len]=dp[l][len-1];
			else dp[l][len]=dp[l+(1<<(len-1))][len-1];
		}
	}
}
int RMQ(int l,int r)//返回最小值下标 
{
	int len=log(r-l+1)/log(2);
	if(dep[dp[l][len]]<dep[dp[r-(1<<len)+1][len]])return dp[l][len];
	else return dp[r-(1<<len)+1][len];
}
int lca(int u,int v)
{
	int mn=min(id[u],id[v]);
	int mx=max(id[u],id[v]);
	return dfn[RMQ(mn,mx)];
} 
int main()
{
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		for(int i=1;i<=n;++i)
		E[i].clear();
		memset(vis,0,sizeof vis);
		memset(id,0,sizeof id);
	    memset(dep,0,sizeof dep);
	    memset(dfn,0,sizeof dfn);
		for(int i=1;i<n;++i)
		{
		    scanf("%d%d",&u,&v);
			E[u].push_back(v);
			vis[v]=1;	
		}
		for(int i=1;i<=n;++i)
		{
			if(!vis[i])
			{
				dfs(i,-1,0);
				break;
			}
		}
		ST();
		scanf("%d%d",&u,&v);
		printf("%d\n",lca(u,v));
	}
	return 0;
} 

三、离线Tarjan（离线O(n)预处理所有答案）

tarjan是向下搜的过程中把答案都预处理了，

①如果搜完一个节点，发现这个节点和另一个已经被搜的节点有询问lca的关系，

那么答案，就是另一个已经被搜的节点的当前的父亲；如果还没搜就先跳过

②搜索回溯的时候，用并查集把它连向它的父亲，

然后根据dfs序，它的父亲就会搜下一个节点，这个节点里如果有节点有询问，就正好回答了lca

离线tarjan的核心思想还是欧拉序的遍历过程中会回到一次根节点，把u连向lca，就能处理对v的回答了

仍以poj1330为例，poj1330这题每棵树只有一个询问

多组询问时，由于离线处理不考虑顺序，可以往询问的vector里打入id号

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
typedef long long ll;
using namespace std;
const int maxn=1e4+10;
vector<int>E[maxn];
vector<int>Q[maxn];
int T,n;
int u,v,ans;
int par[maxn];
bool in[maxn],vis[maxn];
void init(int n)
{
	for(int i=1;i<=n;++i)
	{
		par[i]=i;
		E[i].clear();
		Q[i].clear(); 
		in[i]=vis[i]=0;
	}
} 
int find(int x)
{
	return par[x]==x?x:par[x]=find(par[x]);
}
void unite(int x,int y)
{
	x=find(x),y=find(y);
	if(x==y)return;
	par[y]=x;
}
void dfs(int u,int fa)
{
	vis[u]=1;
	for(int i=0;i<E[u].size();++i)
	{
		int v=E[u][i];
		if(vis[v])continue;
		dfs(v,u);
		unite(u,v);//u is par of v
	}
	for(int i=0;i<Q[u].size();++i)
	{
		int v=Q[u][i];
		if(!vis[v])continue;
		ans=find(v);
	}
}
int main()
{
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		init(n);
		for(int i=1;i<n;++i)
		{
			scanf("%d%d",&u,&v);
			E[u].push_back(v);
			in[v]=1;
		}
		scanf("%d%d",&u,&v);
		Q[u].push_back(v);
		Q[v].push_back(u);
		for(int i=1;i<=n;++i)
		{
			if(!in[i])
			{
				dfs(i,-1);
				break;
			}
		}
		printf("%d\n",ans);
	}
	return 0;
}

四、树剖（在线O(n)预处理，O(logn)查询）