求LCA的两种方法

最新推荐文章于 2022-07-02 08:37:55 发布

JackflyDC

最新推荐文章于 2022-07-02 08:37:55 发布

阅读量296

点赞数 2

分类专栏： OI

本文链接：https://blog.csdn.net/qq_34531807/article/details/79351162

版权

OI 专栏收录该内容

222 篇文章 0 订阅

订阅专栏

一、Tarjan求LCA（离线）

其实这个Tarjan与上一篇讲的四种没有一点联系，它只是Tarjan发明的而且恰好也叫Tarjan，上一篇讲的是求强连通分量的。而这一篇所讲的Tarjan实际上是一种离线算法。

下面讲一下Tarjan算法的基本思路：

1.任选一个点为根节点，从根节点开始。

2.遍历该点u所有子节点v，并标记这些子节点v已被访问过。、

3.若是v还有子节点，返回2，否则下一步。

4.合并v到u上。

5.寻找与当前点u有询问关系的点v。

6.若是v已经被访问过了，则可以确认u和v的最近公共祖先为v被合并到的父亲节点a。

用dfs来遍历，合并最优化的方式就是利用并查集来合并两个节点。

例题POJ1330。模板题。

Code：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#define N 20005
using namespace std;
int head[N],flag[N],father[N],fa[N];
int totre,headre[N],a,b,tot,ancestor[N];
struct edge
{
	int vet,next;
}edge[N],require[N];
void add(int u,int v)
{
	edge[++tot].vet=v;
	edge[tot].next=head[u];
	head[u]=tot;
}
int getfather(int x)
{
	if(x==father[x])return x;
	return father[x]=getfather(father[x]);
}
void merge(int x,int y)
{
	x=getfather(x);
	y=getfather(y);
	if(x!=y)father[x]=y;
}
void tarjan(int u)
{
	for(int i=head[u];i!=-1;i=edge[i].next)
	{
		int v=edge[i].vet;
		tarjan(v);
		merge(u,v);
		ancestor[getfather(u)]=u;
	}
	flag[u]=true;
	for(int i=headre[u];i!=-1;i=require[i].next)
	{
		int v=require[i].vet;
		if(flag[v])
			printf("%d\n",ancestor[getfather(v)]);
	}
}
void addre(int u,int v)
{
	require[++totre].vet=v;
	require[totre].next=headre[u];
	headre[u]=totre;
}
int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		memset(head,-1,sizeof(head));
		memset(headre,-1,sizeof(headre));
		tot=0,totre=0;int n;
		scanf("%d",&n);
		memset(fa,0,sizeof(fa));
		for(int i=1;i<n;i++)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			add(u,v);
			fa[v]++;
		}
		int root;
		memset(flag,false,sizeof(flag));
		for(int i=1;i<=n;i++)
			if(fa[i]==0)root=i;
		scanf("%d%d",&a,&b);
		addre(a,b);addre(b,a);
		for(int i=1;i<=n;i++)
			father[i]=i;
		tarjan(root);
	}
	return 0;
}

二、树上倍增求LCA（在线）

那么接下来看一下倍增算法。它可以在线求树上两个点的LCA。

先通过dfs遍历，记录每个节点的深度deep[u]。

再求出树上每个节点u的2^i祖先fa[u][i]。

然后根据两个节点的的深度，如不同，向上调整深度大的节点，使得两个节点在同一层上，如果正好是祖先结束，否则，将连个节点同时上移，查询最近公共祖先。

这个算法看看非常简单，它的时间复杂度为nlogn。

依然以POJ1330为例。

Code:

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#define N 20005
using namespace std;
int head[N],a,b,tot,fa[N][21],f[N],deep[N];
inline int read()
{
	int x=0,f=1;char s=getchar();
	while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
	while(s<='9'&&s>='0'){x=x*10+s-'0';s=getchar();}
	return x*f;
}
struct edge
{
	int vet,next;
}edge[N];
void add(int u,int v)
{
	edge[++tot].vet=v;
	edge[tot].next=head[u];
	head[u]=tot;
}
void dfs(int u)
{
	for(int i=head[u];i!=-1;i=edge[i].next)
	{
		int v=edge[i].vet;
		if(v==fa[u][0])continue;
		deep[v]=deep[u]+1;
		fa[v][0]=u;
		dfs(v);
	}
}
int lca(int a,int b)
{
	if(deep[a]>deep[b])swap(a,b);
	int d=deep[b]-deep[a];
	for(int i=0;i<=20;i++)
		if((1<<i)&d)b=fa[b][i];
	if(a==b)return a;
	for(int i=20;i>=0;i--)
		if(fa[a][i]!=fa[b][i])
		{
			a=fa[a][i];
			b=fa[b][i];
		}
	return fa[a][0];
}
int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		memset(head,-1,sizeof(head));
		memset(f,0,sizeof(f));
		memset(fa,0,sizeof(fa));
		memset(deep,0,sizeof(deep));
		tot=0;
		int n=read();
		for(int i=1;i<n;i++)
		{
			int u=read(),v=read();
			add(u,v);
			f[v]++;
		}
		int root;
		for(int i=1;i<=n;i++)
			if(f[i]==0)root=i;
		dfs(root);
		for(int j=1;j<=20;j++)
			for(int i=1;i<=n;i++)
				fa[i][j]=fa[fa[i][j-1]][j-1];
		int a=read(),b=read();
		printf("%d\n",lca(a,b));
	}
	return 0;
}