倍增求lca

最新推荐文章于 2024-09-30 12:49:19 发布

原创最新推荐文章于 2024-09-30 12:49:19 发布 · 143 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#算法

算法模板专栏收录该内容

12 篇文章

订阅专栏

本文介绍了最近公共祖先（LCA）的求解方法。首先指出简单“暴力”法时间复杂度高不适用，接着重点讲解利用倍增求LCA，包括预处理求f[i][j]数组，以及求LCA的具体流程，最后给出完整代码思路。

倍增求lca

什么是lca
lca怎么求
流程
完整代码

模板题详见洛谷P3379

什么是lca

$l c a$ ，即 最近公共祖先。具体解释请自行百度~~~（我太弱了）

lca怎么求

1.最简单的方法则是“暴力”。将深度大的节点向上走到与深度小的节点的深度相同；之后两个节点一起向上跳，知道它们所在的节点相同。
但是这种做法的时间复杂度太高了 $Q A Q$ ，所以并不适合。

2.所以考虑利用倍增求lca。先开一个 $f [] []$ 数组， $f [i] [j]$ 表示节点i向上跳 $2^j$ 个单位后的节点，之后再“暴力”求解，这样复杂度就少很多了！

流程

1.常规建边（这个不用解释吧）

void add(int x,int y)
{
	tot++;
	tr[tot].v=y;
	tr[tot].next=head[x];
	head[x]=tot;
}//建边

2.预处理
$d e p [i]$ 表示 节点i的深度， $f a [i]$ ，表示节点i的父节点（其实并没有什么用），重点就是求 $f [i] [j]$ 。可以证明，节点i向上跳 $2^j$ 个节点（即 $f [i] [j]$ ）就是节点i向上跳 2^j-1个节点后的节点（即 $f [i] [j - 1]$ ）再向上跳2^j-1个节点，因为2^j-1+2^j-1=2^j。（原谅我语文不好 $Q A Q$ ，其实可以自己推一下）

void ready(int u,int v)//v是u的父亲
{
	dep[u]=dep[v]+1;
	fa[u]=v;
	//f[u][0]=v;
	for(int i=0;i<=20;i++)
	f[u][i+1]=f[f[u][i]][i];//预处理倍增数组
	for(int t=head[u];t;t=tr[t].next)
	{
		int nw=tr[t].v; 
		if(nw==v)continue;
		f[nw][0]=u;
		ready(nw,u);//dfs
	}
}//预处理

3.接下来就是重点——求 $l c a$ 了
假设要求 $x$ 和 $y$ 节点的 $l c a$ ，且 $x$ 比 $y$ 深，那么我们就利用倍增，先让 $x$ 向上跳，直到与 $y$ 的深度相同。若此时 $x$ 等于 $y$ 节点，则直接返回 $x$ 或 $y$ 节点。若不相同，算法继续。

接下来让 $x$ 和 $y$ 一起向上跳，方法还是倍增。但需注意的是不能让 $x$ 和 $y$ 跳到 $l c a$ 以上的节点，也就是 $f [x] [i]! = f [y] [i]$ 。最后 $x$ 和 $y$ 会分别是 $l c a$ 的子节点，直接返回 $x$ 或 $y$ 的父节点（即 $f [x] [0]$ 或 $f [x] [0]$ ）即可。

int lca(int x,int y)
{
	if(dep[x]<dep[y])swap(x,y);
	for(int i=20;i>=0;i--)
	{
		if(dep[f[x][i]]>=dep[y])x=f[x][i];//保证x一直比y深或与y深度相同
		if(x==y)return x;//有答案则直接得出答案
	}//让x与y的深度相同
	for(int i=20;i>=0;i--)
	{
		if(f[x][i]!=f[y][i])//不同说明没有超过lca，跳
		{
			x=f[x][i];
			y=f[y][i]; 
		}
	}
	return f[x][0];//最终是在lca的子节点停下来
}//先跳到同一深度，再同时向上跳

完整代码

#include<cstdio>
#include<algorithm>
#define maxn 500005
using namespace std;

struct tree
{
	int v,next;
}tr[maxn*4];

int n,m,s,tot,head[maxn];
int f[maxn][25],fa[maxn],dep[maxn],ans[maxn];//f[i][j]表示点i跳2^j的节点,dep表示节点的深度

void add(int x,int y)
{
	tot++;
	tr[tot].v=y;
	tr[tot].next=head[x];
	head[x]=tot;
}//建边

void ready(int u,int v)//v是u的父亲
{
	dep[u]=dep[v]+1;
	fa[u]=v;
	//f[u][0]=v;
	for(int i=0;i<=20;i++)
	f[u][i+1]=f[f[u][i]][i];//预处理倍增数组
	for(int t=head[u];t;t=tr[t].next)
	{
		int nw=tr[t].v; 
		if(nw==v)continue;
		f[nw][0]=u;
		ready(nw,u);//dfs
	}
}//预处理

int lca(int x,int y)
{
	if(dep[x]<dep[y])swap(x,y);
	for(int i=20;i>=0;i--)
	{
		if(dep[f[x][i]]>=dep[y])x=f[x][i];//保证x一直比y深或与y深度相同
		if(x==y)return x;//有答案则直接得出答案
	}//让x与y的深度相同
	for(int i=20;i>=0;i--)
	{
		if(f[x][i]!=f[y][i])//不同说明没有超过lca，跳
		{
			x=f[x][i];
			y=f[y][i]; 
		}
	}
	return f[x][0];//最终是在lca的子节点停下来
}//先跳到同一深度，再同时向上跳

int main()
{
	scanf("%d%d%d",&n,&m,&s);
	for(int i=1;i<n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		add(x,y);
		add(y,x);
	}//建边
	ready(s,0);//预处理
	for(int i=1;i<=m;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		ans[i]=lca(x,y);
	}
	for(int i=1;i<=m;i++)
	printf("%d\n",ans[i]);
	return 0;
}

终于写完了，我还是太弱了。