算法学习笔记——最近公共祖先（LCA）模板

除了水还能做什么呢

于 2021-08-18 00:37:52 发布

阅读量154

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/qq_52177557/article/details/119754000

版权

数据结构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

模板题地址：https://www.luogu.com.cn/problem/P3379

定义：

最近公共祖先简称 LCA（Lowest Common Ancestor）。两个节点的最近公共祖先，就是这两个点的公共祖先里面，离根最远的那个，指的是离两个点最近的公共祖先节点。（OI-wiki）

求法：

一、暴力求法：

每次将u、v中深度较大的节点向上跳到其父节点，因为两个节点都存在于同一颗树上，因此两个点必然会相遇，那么这个相遇的节点就会是两个点的最近公共祖先（LCA）

对于这种做法，最坏的情况就是需要dfs搜索整棵树，因此，每次询问一次的复杂度最坏会达到 $O (n)$ ；因为树结构的随机性，因此询问的平均复杂度为 $O (l o g n)$ ，总体复杂度较高

二、倍增求法：

倍增求法属于是LCA求法中比较常用的一种求法，属于是暴力求法的优化，是一种可以在线求LCA的求法。通过预处理，可以快速每个节点的第 $2^k$ 个祖先节点，从而缩短往上跳的时间，更快求出LCA。

在预处理中，我们用 $f a [i] [k]$ 来记录 $i$ 节点的第 $2^k$ 个祖先，那么我们可以通过dfs，并通过 $f a [i] [k] = f a [f a [i] [k - 1]] [k - 1]$ 来对祖先进行计算，预处理复杂度为 $O (n l o g n)$

而对于LCA的计算，先快速将两个节点提到同一层，再两边同时不断向上找父节点，直到找到LCA，查询复杂度为 $O (l o g n)$

放上代码：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int inf=0x3f3f3f3f;
const int mod=1e9+7;
const int N=5e5+5;
struct qxx{
    int f,v;
}q[2*N];
int n,m,s;
int dep[N],fa[N][22],lg[N];
//dep(深度)存每个数的层数，fa存每个点的2^i个祖先
//lg用来计算第2^k个父节点的k 
int zs,head[N];
void cun(int x,int y) //链式前向星存树 
{
    q[++zs].v=y; 
    q[zs].f=head[x];
    head[x]=zs;
}

void dfs(int s,int fs) //深搜层数 、父节点,fs为父节点数 
{
    dep[s]=dep[fs]+1;
    fa[s][0]=fs;
    for(int i=1;(1<<i)<=dep[s];i++) //计算 
      fa[s][i]=fa[fa[s][i-1]][i-1];
    for(int i=head[s];i;i=q[i].f)
      if(q[i].v!=fs)
        dfs(q[i].v,s);
}

int lca(int x,int y)
{
    if(dep[x]<dep[y])
      swap(x,y);
    while(dep[x]>dep[y])
      x=fa[x][lg[dep[x]-dep[y]]]; //将st提到与e同层 
    if(x==y) return x;
    for(int i=lg[dep[x]];i>=0;i--)  //同时往上提找LCA 
      if(fa[x][i]!=fa[y][i])
        x=fa[x][i], y=fa[y][i];
    return fa[x][0];
}
int main()
{
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<n;i++)
    {
        int x,y;
		scanf("%d%d",&x,&y);
        cun(x,y); cun(y,x);
    }
    dfs(s,0);
    lg[0]=-1;
    for(int i=1;i<=n;i++)
      lg[i]=lg[i/2]+1;
    for(int i=1;i<=m;i++)
    {
        int x,y;
		scanf("%d%d",&x,&y);
        printf("%d\n",lca(x,y));
    }
    return 0;
}

三、Trajan求法：

Trajan求法是一种离线的LCA求法，需要使用并查集记录某个结点的祖先结点，利用dfs就能实现所有LCA的查询，与前面的方法有些许不同。

对于每个点，我们都会记录下与它有关的询问，同时，我们还要记录一个v代表记录该点是否被访问，fa记录该点的父节点

对于整个trajan的求法，可以分成4步：

1、从根节点u开始，遍历每个节点的子节点v，并将其标记为已访问
2、若仍存在子节点，重复1的过程
3、并查集合并u、v
4、遍历与v有关的查询，若在一组查询中点x已经搜过，则v、x两点的公共祖先为v合并到的祖先节点a

具体做法流程参考（详细好懂）：https://www.cnblogs.com/JVxie/p/4854719.html

放上代码：

#include<bits/stdc++.h>
#define endl '\n'
using namespace std;
const int N=500005;
const int inf=0x3f3f3f3f;
int n,m,s;
int fa[N],ans[N];
struct qxx{
	int fr,y;
}q[2*N];
int zs,head[N];
vector<int> d[N],x[N];
bool v[N];

void cun(int x,int y)
{
	q[++zs].fr=head[x];
	q[zs].y=y;
	head[x]=zs;
}

void add(int a,int b,int xh)   //存每次的公共祖先询问 
{
	d[a].push_back(b); x[a].push_back(xh);
	d[b].push_back(a); x[b].push_back(xh);
}

int ff(int x)
{
	if(fa[x]==x) return x;
	else return fa[x]=ff(fa[x]);
}

void trajan(int u)
{
	v[u]=1;
	for(int i=head[u];i;i=q[i].fr)
	{
		int y=q[i].y;
		if(v[y]) continue;
		trajan(y);
		fa[y]=u;
	}
	for(int i=0;i<d[u].size();i++)
	{
		if(v[d[u][i]])  //如果询问的另一个点已经找过了 
		{
			int fx=ff(d[u][i]);  //找合并的父节点即为公共祖先 
			ans[x[u][i]]=fx;
		}
	}
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin>>n>>m>>s;
	for(int i=1;i<=n;i++)
	    fa[i]=i;
	for(int i=1;i<n;i++)
	{
		int a,b;
		cin>>a>>b;
		cun(a,b); cun(b,a);
	}
	for(int i=1;i<=m;i++)
	{
		int a,b;
		cin>>a>>b;
		if(a==b) ans[i]=0;
		else ans[i]=inf; //初始化答案数组 
		add(a,b,i); add(b,a,i); //存入每次询问 
	}
	trajan(s);
	for(int i=1;i<=m;i++) 
	    cout<<ans[i]<<endl;
	return 0;
}