浅谈LCA相关算法（tarjan，倍增）

最新推荐文章于 2024-05-15 16:38:48 发布
最新推荐文章于 2024-05-15 16:38:48 发布
阅读量638 收藏
点赞数
分类专栏： 图论算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43907802/article/details/86595493
版权

其实LCA算法的理解也没那么麻烦

tarjan

这是一棵树，我们不难发现，9和12的公共祖先是3，且当我们走到12时，9一定被访问过了，3也一定被访问过了

然后tarjan的大脑就发现了一个问题：如果说我们可以知道访问过的点的祖先，那么图中，我们在dfs到节点12时不就可以直接认为9和12的公共祖先是在9之后遍历到的深度最小的点（即3）了吗？

（其实到了这一步，我们就可以发现两种做法，一种使用RMQ，另一种是tarjan，RMQ暂且不提）

因此，我们可以使用并查集来将已遍历过的点归到他们的祖先上，然后将问题存储起来，若问题中的两个节点都被访问过了，那么我们就可以直接返回先被遍历的那个节点的父节点即可

这其实就是tarjan的基本思想

本人自己打的tarjan如下，具体细节都有解释（luoguP3379码风奇特的奇特）

#include<bits/stdc++.h>
using namespace std;
#define fre freopen("datain.txt","r",stdin);
//**********************************data
const int maxn=500000+5;
const int maxm=500000+5;
int n,m,s;
int f[maxn],head[maxn],cnt=0;
struct node
{
	int e;
	int next;
}edge[maxn<<1];
struct ans
{
	int question;//某一次询问的对象
	int id;//这个对象对应的序号
};
vector<ans>vec[maxn];//定义一个二维变长数组的方法
bool vis[maxn];
int output[maxm];
//**********************************function defination
inline int read();//快读
int find(int u);//并查集函数
void tarjan(int u,int fa);//tarjan函数（dfs）
void datasetting();//处理输入数据函数
void addl(int u,int v);//边表加边函数
//**********************************main
int main()
{
   fre
   datasetting();
   tarjan(s,-1);//根的fa是-1
   for(int i=0;i<m;i++)printf("%d\n",output[i]);输出ans
   return 0;
}
//**********************************function 
void addl(int u,int v)
{
	edge[cnt].e=v;
	edge[cnt].next=head[u];
	head[u]=cnt++;
}
void datasetting()
{
	memset(head,-1,sizeof(head));
	memset(vis,0,sizeof(vis));
	n=read();m=read();s=read();
	int u,v;
	for(int i=0;i<n-1;i++)
	{
		u=read();v=read();
		addl(u,v);
		addl(v,u);
	}
	for(int i=0;i<m;i++)
	{//为了让答案有序，我们需要将对应的询问节点与询问次序结合起来，于是就想到用结构体（在这里是ans）
		u=read();v=read();
		ans r;r.id=i;r.question=v;
		vec[u].push_back(r);
		r.question=u;
		vec[v].push_back(r);
	}
}
inline int read()
{
	int ans=0;
	char r=getchar();
	while(r<'0'||r>'9')r=getchar();
	while(r>='0'&&r<='9')
	{
		ans=ans*10+r-'0';
		r=getchar();
	}
	return ans;
}
int find(int u)
{
	return f[u]= f[u]==u ? u:find(f[u]);
    //问号表达式，若问号左边的条件成立，则返回冒号左边的值，否则返回冒号右边的值
}
void tarjan(int u,int fa)
{
	f[u]=u;//先将自己作为根节点
	for(int i=head[u];i!=-1;i=edge[i].next)//遍历
	{
		int v=edge[i].e;
		if(v==fa)continue;//这是为什么函数实参里要带一个fa的原因，可以避免从子走到父，保证dfs序
		tarjan(v,u);//向下dfs
		f[find(v)]=u;//在下面的询问都处理完了以后将下面的点并到自己身上来
	}
	vis[u]=true;//dfs标记
	int s=vec[u].size();
	for(int i=0;i<s;i++)//检查每一个关于u的询问
	{
		int v=vec[u][i].question;int e=vec[u][i].id;
		if(vis[v])output[e]=find(v);//若成立，在output数组里面（即答案数组）按顺序放入答案
	}
}
/**********************************
ID:Andrew_82
LANG:C++
PROG:LCA
**********************************/

倍增

以上是tarjan算法，接下来我们来看一下倍增算法

对与一棵树里的两个点，我们要找其最近公共祖先，最容易想到的方法就是将俩个点不断的向上追溯其祖先，直到找到第一个相交的祖先即可

就像这样

以下所有图片来自

http://www.cnblogs.com/yyf0309/p/5972701.html）

但是，一个一个的跳，也太慢了，我们可不可以大步大步的跳？

答案是可以的

设树的最大深度为d，对于每一个节点，最坏情况下与根节点的距离为就是d

然后，我们可以将d拆成不多于20个2的n次方的数相加的形式

每次跳 2 i {2}^{i} 2i步（ 0 &lt; i &lt; = ln ⁡ d ln ⁡ 2 0&lt;i&lt;=\frac{\ln d}{\ln2} 0<i<=ln2lnd​，i倒序遍历）

这样就可以避免缓慢的跳跃了

这也是倍增算法的原理

当然，要实现这一功能，我们需要一个表 f [ i ] [ j ] f[i][j] f[i][j],表示i号节点向上跳跃 2 j {2}^{j} 2j步所到达的点

这个表可以用以下递推式来求得：

f [ i ] [ j ] = f [ f [ i ] [ j − 1 ] ] [ j − 1 ] f[i][j]=f[f[i][j-1]][j-1] f[i][j]=f[f[i][j−1]][j−1]

即i向上 2 j {2}^{j} 2j,等价于i向上 2 j − 1 {2}^{j-1} 2j−1步后继续向上 2 j − 1 {2}^{j-1} 2j−1步
其实这不难理解，毕竟：
2 j − 1 + 2 j − 1 = 2 1 × 2 j − 1 = 2 j − 1 + 1 = 2 j {2}^{j-1}+{2}^{j-1}={2}^{1} \times{2}^{j-1}={2}^{j-1+1}={2}^{j} 2j−1+2j−1=21×2j−1=2j−1+1=2j
不难看出，f[i][j−1]是i的上层节点，于是递推顺序应该是从上往下（dfs就满足这个特性），当上层的点的f值被算出来后，就可以放心的计算本层的f值了

下面给出代码（luoguP3379）

#include<bits/stdc++.h>
using namespace std;
int n,m,s,maxd=0,b;
const int maxn=500000+5,maxm=500000+5;
int dfn[maxn];//其实这里是指深度而非时间戳
int f[maxn][20];//倍增数组 
struct node{
	int e;
	int next;
}edge[maxm<<1];
int head[maxn],cnt=0;


inline int read()//快读
{
    int ans=0;
    char r;r=getchar();
    while(r<'0'||r>'9')r=getchar();
    while(r>='0'&&r<='9')
    {
        ans=ans*10+r-'0';
        r=getchar();
    }
    return ans;
}


void addl(int u,int v)//加边不说了
{
	edge[cnt].e=v;
	edge[cnt].next=head[u];
	head[u]=cnt++;
}


void datasetting()
{
	memset(head,-1,sizeof(head));
	memset(f,-1,sizeof(f));
	n=read();m=read();s=read();
	int u,v;
	for(int i=0;i<n-1;i++)//based on one
	{
		u=read();v=read();
		addl(u,v);
		addl(v,u);
	}
}


void dfs(int u)//主要目的是要求得最大深度和f[i][0](即每个点的father值)，为后面的倍增数组做准备 
{
	if(f[u][0]!=-1)maxd=max(maxd,dfn[u]=dfn[f[u][0]]+1);//同时完成给子节点赋值和求最大深度两件事 
	for(int i=head[u];i!=-1;i=edge[i].next)
	{
		int v=edge[i].e;
		if(v==f[u][0])continue;
		f[v][0]=u;
		dfs(v);
	}
}


void Double()//求倍增数组，i的第2^j个父亲 是i的第2^(j-1)个父亲的第2^(j-1)个父亲。
{
	for(int j=1;j<=b;j++)
	{
		for(int i=1;i<=n;i++)
		{
			if(f[i][j-1]!=-1)f[i][j]=f[f[i][j-1]][j-1];
		}
	}
}


int LCA(int u,int v)//先让u，v处于同一高度，然后在逐次向上以倍增的方式提，直到出答案
{
	if(dfn[u]<dfn[v]){int weret=u;u=v;v=weret;}
	for(int i=b;i>=0;i--)if(f[u][i]!=-1&&dfn[f[u][i]]>=dfn[v])u=f[u][i];
	if(v==u)return v;
	for(int i=b;i>=0;i--)
	{
		if(f[u][i]!=f[v][i])
		{
			u=f[u][i];
			v=f[v][i];
		}
	}
	return f[v][0];
}


int main()
{
	freopen("datain.txt","r",stdin);
	datasetting();
	dfs(s);
	b=(int)(log(maxd)/log(2));//这是在对这棵树中最深的一个点的深度取2的对数
    //这个点向上走2^b层不会超过根节点的深度，而走2^(b+1)步则会
	Double();//其实最好不要用这个名字，因为容易忽略大写D
	int s,e;
	for(int i=0;i<m;i++)
	{
		s=read();e=read();
		printf("%d\n",LCA(s,e));
	}
	return 0;
}
/*************************************************
    ID: Andrew_82
	LANG: C++
	PROG: LCA
*************************************************/

loj#10130:

#include<bits/stdc++.h>
using namespace std;
#define loop(i,start,end) for(register int i=start;i<=end;++i)
#define clean(arry,num); memset(arry,num,sizeof(arry));
#define max(a,b) ((a>b)?a:b)
#define min(a,b) ((a<b)?a:b)
int n,q,cnt=0;
const int maxn=1e5+10;
struct node
{
	int e;
	int nxt;
}edge[maxn<<1];
int head[maxn];
int jump[maxn][30];
int dep[maxn];
inline int read()
{
	int _ans=0;bool _neg=false;char _r=getchar();
	while(_r>'9'||_r<'0'){if(_r=='-')_neg=true;_r=getchar();}
	while(_r>='0'&&_r<='9'){_ans=_ans*10+_r-'0';_r=getchar();}
	return (_neg)?-_ans:_ans;
}
inline void addl(int u,int v)
{
	edge[cnt].e=v;
	edge[cnt].nxt=head[u];
	head[u]=cnt;
	cnt++;
}
void dfs(int u,int fa)
{
	jump[u][0]=fa;
	for(int i=1;(1<<i)<=dep[u];++i)//在dfs模块里打表，代码量减少
	//用(1<<i)<=dep[u]来代替了求树的最大深度,更好理解和操作
		if(jump[u][i-1]!=-1)
			jump[u][i]=jump[jump[u][i-1]][i-1];
	for(int i=head[u];i!=-1;i=edge[i].nxt)
	{
		int v=edge[i].e;
		if(v==fa)continue;
		dep[v]=dep[u]+1;
		dfs(v,u);
	}
}
int lca(int x,int y)
{
	if(x==y)return x;//不要忘了这一句
	if(dep[x]<dep[y]){int t=x;x=y;y=t;}
	for(int i=20;i>=0;--i)
	{
		if(dep[jump[x][i]]>=dep[y])x=jump[x][i];
	}
	if(x==y)return x;//注意这一句也不能忘
	for(int i=20;i>=0;--i)
	{
		if(jump[x][i]!=jump[y][i])x=jump[x][i],y=jump[y][i];
	}//跳到LCA的下面
	return jump[x][0];
}
int main()
{
	#ifndef ONLINE_JUDGE
    freopen("datain.txt","r",stdin);
    #endif
    n=read();
    clean(head,-1);
    clean(jump,-1);
    clean(dep,0);
    loop(i,1,n-1)
    {
    	int x,y;
    	x=read(),y=read();
    	addl(x,y);
    	addl(y,x);
	}
	dfs(1,-1);
	q=read();
	loop(i,1,q)
	{
		int x,y;
		x=read();
		y=read();
		int LCA=lca(x,y);
		printf("%d\n",dep[x]+dep[y]-(dep[LCA]<<1));
	}
	return 0;
}

推荐题目：

CODEVS 2370 小机房的树

CODEVS 1036 商务旅行

METO CODE 223 拉力赛

HDU 2586 How far way?

ZOJ 3195 Design the city

AndrewMe8211
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++最近公共祖先LCA（倍增算法和tarjan）
Tekim的博客
09-01 6470
1.倍增 找两个点的LCA，先让它们深度相同，然后倍增向上跳跃，跳到使他们的值不相同的最浅层的点，那么此点的上方即是LCA。 #include #include #include #include #include #include #include #define in(x) scanf("%d",&x); using namespace std; int n,m,rt,d[500007],
LCA问题——倍增算法，Tarjan算法讲解
Lean的博客
01-24 1881
LCA问题 前言：助力信息奥赛！ 1.LCA &RMQ 首先回想一下RMQ问题：给出一个数组，有多次询问，每次询问一段区间内的最大值。
LCA（最近公共祖先）——Tarjan
weixin_34148456的博客
03-13 167
什么是最近公共祖先？ 在一棵没有环的树上，每个节点肯定有其父亲节点和祖先节点，而最近公共祖先，就是两个节点在这棵树上深度最大的公共的祖先节点。 换句话说，就是两个点在这棵树上距离最近的公共祖先节点。 所以LCA主要是用来处理当两个点仅有唯一一条确定的最短路径时的路径。 常用来求LCA的算法有：Tarjan/DFS（离线），ST/倍增（在线）。 1，Tarjan tarjan...
算法学习系列（六十二）：LCA（最近公共祖先）：倍增法、Tarjan算法
最新发布
weixin_60033897的博客
05-15 1092
关于这个 $LCA$ 问题蓝桥杯这两年考的是也是越来越多了，尤其是去年直接出了个裸题（模板题），也是没想到的，再加上今年省赛 $java$ 组也出了一道与之相关的题，所以今年国赛感觉出的几率也是有的。学下来发现其实也没那么难，又是自己想神秘了，思路和代码总的来说都不是很难，难的是想法，这道题你能否能想到用 $LCA$ 做才是关键，所以本章内容还是采用讲题的策略来进行讲解，就其实都是非常经典的问题，几乎都是模板题，但是我觉得蓝桥杯应该不会出特别难的了，因为本身这个算法就很难，还是要多写写熟即可，继续加油吧！
LCA 与 tarjan 实现的原理
qq_42873341的博客
07-08 261
P3379 LCA模板 这里写到的是用tarjan与并查集求LCA。 首先回顾一下tarjan算法： 核心代码： for (int i = head[u]; i; i = edge[i].next) { int v = edge[i].to; tarjan(v); //递归返回，代表此时已经遍历完以 u 为节点的子树，u 根据每次递归层数，u 是不同的 } 它是一个可以将一张有向图或无向图遍历D...
Tarjan算法_LCA
A_Bo的博客
03-30 6914
首先我们要知道什么是LCA、深度优先生成树以及并查集在计算LCA的算法中我们有离线算法以及在线算法两种，我们这里使用的Tarjan算法是使用的是离线算法，即将所有的问题一次性输入，然后再一次性输出答案本人感觉这个算法的写法和Tarjan写法还是有很大差距的，相同的地方大部分是在思想上我们首先来举个例子，模拟一下这个算法的实现过程假设这是我们要计算的树，我们要计算7--8，5--6，5--2，4--...
LCA (最近公共祖先) Tarjan & 倍增
01-03
LCA Tarjan： 实现原理 理解：离线算法，建好树后再查询，一次DFS 吧所有查询解决完。 时间复杂度：O(n+q)； n个点 q次询问 补一下：链式向前星，并查集 ，Tarjan 代码 #include #include #include #include #...
倍增：C++算法教程（临时保存）
11-09
常见的LCA算法有在线和离线两种，包括预处理每次查询、在线转换为RMQ、在线转换为±1RMQ、Tarjan算法、树链剖分和Link Cut Tree等。这些算法在预处理和查询阶段的时间复杂度各有不同，但都比暴力遍历整棵树的方式要...
ACM2020倍增+LCA.pdf
04-09
Tarjan算法是一种常用的LCA算法，它可以在O(n)时间内计算出任意两个节点的最近公共祖先。算法的主要思想是从u开始深度遍历每个节点，然后看v点是否被访问过，若有，则u为u和v的最近公共祖先，若无，则向上遍历father...
lca.rar_LCA
09-24
- **Tarjan's offline LCA算法**：利用深度优先搜索遍历整个树，并在线性时间内预处理出所有节点对的LCA信息。 - **Morris遍历**：通过不使用显式的栈空间进行DFS，可以高效地找到LCA，但实现起来相对复杂。 2. *...
浅谈一些树形问题_高胜寒.ppt
09-14
最近公共祖先（LCA）是树形问题中的另一个核心概念，有多种不同的算法实现，如暴力搜索、倍增算法、DFS序方法、Tarjan算法和树链剖分算法。每种方法在时间复杂度和空间复杂度上有不同的权衡，适用于不同规模的问题。...
Tarjan 的 LCA 算法
03-19
c++写的Tarjan 的 LCA 算法，最近公共祖先算法，可供算法学习参考
LCA - Tarjan 模板 介绍与实现
溢流眼泪的博客
07-22 256
LCA - Tarjan 模板 介绍与实现普通的介绍什么是LCA为什么我需要Tarjan算法求LCA？原理ADT 普通的介绍 在我们小学二年级学习过的《算法导论》第三版 第337页上，有一个思考题（什！这么重要的内容只是思考题吗！） 介绍的就是Tarjan 的脱机最小公共祖先 (Tarjan’s Offline Least-Common-Ancestors Problem) 什么是LCA LCA，就是 Least-Common-Ancestors ，指在一棵树中，两个节点的最近的公共祖先。 在这棵以E为根
LCA(倍增和tarjan算法)
m0_50966319的博客
09-02 413
求解lca
LCA 朴素算法+树差分&倍增+Tarjan算法 三种算法实现c++代码实现
xxxxxiao123的博客
07-10 547
转载：http://acm.picpic.site/20200325/code.html 文章目录树差分 & 倍增LCATarjan朴素算法 树差分 & 倍增LCA // 链式前向星 // maxn不要随便开很大 -> 容易MLE const int maxn = 4e4 + 5; ​ // 存无向边 -> 边要开两倍 const int maxm = (maxn - 1) << 1; ​ // 与maxn有关 // 1e6 -> 21 //
[最近公共祖先]tarjan算法实现LCA
qsnighk_的博客
08-17 257
tarjan算法实现LCA写在前面正文目的举个简单的例子朴素算法流程1.存储询问2.遍历代码1.定义2.记录查询3.并查集基本操作4.遍历后记 写在前面 本蒟蒻晚上闲得无聊，随便写写，感谢大家的观看 有错误请多多指出 正文 本文讲解如何使用 tarjan算法 求LCA tarjan算法是一种 离线 算法 目的 首先了解一下 LCA LCA（Least Common Ancestors），即最近公共祖先，是指这样一个问题：在有根树中，找出某两个结点u和v最近的公共祖先（另一种说法，离树根最远的公共祖先）
[Tarjan LCA] TarjanLCA学习笔记
Antimonysbguy的博客
10-26 141
【算法】LCA的三种算法
wahgreh的博客
02-04 2515
离线用Tarjan，在线用倍增。：）
lca算法思想
qq_53737964的博客
02-04 2460
lca(least Comment Ancestors,最近公共祖先问题),是指给定一棵有根树,查询LCA(u,v)，每次求树中两个顶点u和v的最近公共祖先，即找到一个节点，同时是u和v的祖先，并且深度尽可能的大，入度尽可能的大。 一、一般解法 一般解法即暴力小跳，同过逐级跳转向上查询，时间复杂度较大。 先找到给出节点，并得到他们的入度，使入度较大的节点先跳转至与较小节点同一入度的父节点。然后同时向上查找，直至两者相遇。 注意：在这里向上查找都是逐步向上查找的。 结束条件：查询到同一节点时。 二、跳表解法（
LCA用tarjan算法
07-14
Tarjan算法也可以用于求解LCA问题，在有向无环图（DAG）中。 具体来说，在使用Tarjan算法求解LCA时，我们需要进行两次DFS遍历。首先，我们从根节点开始，遍历每个节点，并记录每个节点的深度（即从根节点到该节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AndrewMe8211

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值