求lca（最近公共祖先）的各种方法

最新推荐文章于 2024-04-24 22:20:45 发布
最新推荐文章于 2024-04-24 22:20:45 发布
阅读量4.4k 收藏 15
点赞数 3
分类专栏： 模版 文章标签： 信息学 树 lca c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cold_Chair/article/details/71249622
版权

其实很早前就学了求lca的方法，但是当时没有总结归纳的习惯，现在再把这些总结一遍。

暴力往上跳

先把x,y跳到同一层，然后再同时往上跳，直到成了同一个点，显然这个点就是它们的lca。
时间复杂度最坏是树的深度，树成一条链时，就GG了。

#include<cstdio>
#include<algorithm>
#define fo(i, x, y) for(int i = x; i <= y; i ++)
using namespace std;

const int Maxn = 100005;
int n, x, y;
int final[Maxn], tot;
struct edge {
	int next, to;
}e[Maxn * 2];

int bz[Maxn], dep[Maxn], fa[Maxn];

void link(int x, int y) {
	e[++ tot].next = final[x], e[tot].to = y, final[x] = tot;
	e[++ tot].next = final[y], e[tot].to = x, final[y] = tot;
}

void dg(int x) {
	bz[x] = 1;
	for(int k = final[x]; k; k = e[k].next) {
		int y = e[k].to; if(bz[y]) continue;
		dep[y] = dep[x] + 1;
		fa[y] = x;
		dg(y);
	}
}

void Init() {
	scanf("%d", &n);
	fo(i, 1, n - 1) {
		scanf("%d %d", &x, &y);
		link(x, y);
	}
}

int Lca(int x, int y) {
	if(dep[x] < dep[y]) swap(x, y);
	while(dep[y] > dep[x]) y = fa[y];
	while(x != y) x = fa[x], y = fa[y];
	return x;
}

void Build() {
	dep[1] = 1; dg(1);
}

int main() {
	Init();
	Build();
	
	scanf("%d %d", &x, &y);
	printf("%d", Lca(x, y));
}

倍增跳法

维护每个点向上跳2^j层后是哪个点，这是一个倍增表，过程与Rmq类似（见标）。
假设有x,y（dep[x] < dep[y]）
先将y跳到x那儿。
然后开始二分逼近，不断逼近到lca下面那一个点，再往上一层就是lca了。

#include<cstdio>
#include<algorithm>
#define fo(i, x, y) for(int i = x; i <= y; i ++)
#define fd(i, x, y) for(int i = x; i >= y; i --)
using namespace std;

const int Maxn = 100005, Maxc = 16;
int n, x, y;
int final[Maxn], tot;
struct edge {
	int next, to;
}e[Maxn * 2];

int bz[Maxn], dep[Maxn], fa[Maxn];
int fj[Maxc + 1][Maxn];

void link(int x, int y) {
	e[++ tot].next = final[x], e[tot].to = y, final[x] = tot;
	e[++ tot].next = final[y], e[tot].to = x, final[y] = tot;
}

void dg(int x) {
	bz[x] = 1;
	for(int k = final[x]; k; k = e[k].next) {
		int y = e[k].to; if(bz[y]) continue;
		dep[y] = dep[x] + 1;
		fa[y] = x;
		dg(y);
	}
}

void Init() {
	scanf("%d", &n);
	fo(i, 1, n - 1) {
		scanf("%d %d", &x, &y);
		link(x, y);
	}
}

int Lca(int x, int y) {
	if(dep[x] > dep[y]) swap(x, y);
	fd(i, Maxc, 0) if(dep[fj[i][y]] >= dep[x]) y = fj[i][y];
	fd(i, Maxc, 0) if(fj[i][x] != fj[i][y]) x = fj[i][x], y = fj[i][y];
	return x == y ? x : fa[x];
}

void Build() {
	dep[1] = 1; dg(1);
	fo(i, 1, n) fj[0][i] = fa[i];
	fo(j, 1, Maxc) fo(i, 1, n) fj[j][i] = fj[j - 1][fj[j - 1][i]];
}

int main() {
	Init();
	Build();
	
	scanf("%d %d", &x, &y);
	printf("%d", Lca(x, y));
}

欧拉序+Rmq求lca

欧拉序：就是沿着树一直走，可以倒着走，途中经过所有点就是欧拉序。
这里写图片描述
如图，它的欧拉序就是1-2-3-2-1-4-5-4-1

很显然，两个点的lca就是它们在欧拉序中的位置中间的深度最小的那个点，如果一个点在欧拉序中出现了多次，随便取一个即可。
欧拉序的长度不会超过点数的2倍，查询时O(1)的。

#include<cmath>
#include<cstdio>
#include<algorithm>
#define fo(i, x, y) for(int i = x; i <= y; i ++)
#define fd(i, x, y) for(int i = x; i >= y; i --)
#define min(a, b) ((a) < (b) ? (a) : (b))
using namespace std;

const int Maxn = 100005, Maxc = 18;
int n, x, y;
int final[Maxn], tot;
struct edge {
	int next, to;
}e[Maxn * 2];

int bz[Maxn], dep[Maxn], fa[Maxn], d[Maxn * 2], dt[Maxn], d0;
int a2[Maxc + 1], fj[Maxc + 1][Maxn * 2];

void link(int x, int y) {
	e[++ tot].next = final[x], e[tot].to = y, final[x] = tot;
	e[++ tot].next = final[y], e[tot].to = x, final[y] = tot;
}

void dg(int x) {
	bz[x] = 1;
	d[++ d0] = x; dt[x] = d0;
	for(int k = final[x]; k; k = e[k].next) {
		int y = e[k].to; if(bz[y]) continue;
		dep[y] = dep[x] + 1;
		fa[y] = x;
		dg(y);
		d[++ d0] = x; dt[x] = d0;
	}
}

void Init() {
	scanf("%d", &n);
	fo(i, 1, n - 1) {
		scanf("%d %d", &x, &y);
		link(x, y);
	}
}

int Lca(int x, int y) {
	if(dt[x] > dt[y]) swap(x, y);
	int lg = log2(dt[y] - dt[x] + 1);
	return dep[fj[lg][dt[x]]] < dep[fj[lg][dt[y] - a2[lg] + 1]] ? fj[lg][dt[x]] : fj[lg][dt[y] - a2[lg] + 1];
}

void Build() {
	a2[0] = 1; fo(i, 1, Maxc) a2[i] = a2[i - 1] * 2;
	dep[1] = 1; dg(1);
	fo(i, 1, d0) fj[0][i] = d[i];
	fo(j, 1, Maxc) fo(i, 1, d0)
		fj[j][i] = dep[fj[j - 1][i]] < dep[fj[j - 1][min(d0, i + a2[j - 1])]] ? fj[j - 1][i] : fj[j - 1][min(d0, i + a2[j - 1])];
}

int main() {
	Init();
	Build();
	
	scanf("%d %d", &x, &y);
	printf("%d", Lca(x, y));
}

Tarjan

这是我会的唯一 一种线性算法，实际上，它的常数有点大，在小数据级跑得可能比以上的log算法还慢，OI一般也不会卡，但是确实出题人说他会线性算法的必备算法（比如GDOI2017）。
流程：
把各个询问打在两个点上。

递归，对于当前节点，先递归求子树内的lca
把挂在这个点上的询问一一处理，如果询问上的另一点已经遍历过，lca为另一点的并查集中的祖先。
把当前点在并查集中的父亲设为它在树上的父亲。
递归结束。

证明自己画个图搞搞吧。

#include<cmath>
#include<cstdio>
#include<algorithm>
#define fo(i, x, y) for(int i = x; i <= y; i ++)
#define fd(i, x, y) for(int i = x; i >= y; i --)
#define min(a, b) ((a) < (b) ? (a) : (b))
using namespace std;

const int Maxn = 100005, Maxc = 18;
int n, x, y, Q, ans[Maxn], f[Maxn];
int final[Maxn], tot, final2[Maxn], tot2;
struct edge {
	int next, to, w;
}e[Maxn * 2], e2[Maxn * 2];

int bz[Maxn], dep[Maxn], fa[Maxn];

int find(int x) {
	return f[x] == x? x : (f[x] = find(f[x]));
}

void link(int x, int y) {
	e[++ tot].next = final[x], e[tot].to = y, final[x] = tot;
	e[++ tot].next = final[y], e[tot].to = x, final[y] = tot;
}

void link2(int x, int y, int z) {
	e2[++ tot2].next = final2[x], e2[tot2].to = y, e2[tot2].w = z, final2[x] = tot2;
	e2[++ tot2].next = final2[y], e2[tot2].to = x, e2[tot2].w = z, final2[y] = tot2;
}

void Init() {
	scanf("%d", &n);
	fo(i, 1, n - 1) {
		scanf("%d %d", &x, &y);
		link(x, y);
	}
}


void Build() {
	scanf("%d", &Q);
	fo(i, 1, Q) {
		scanf("%d %d", &x, &y);
		link2(x, y, i);
	}
	fo(i, 1, n) f[i] = i;
}

void dg(int x) {
	bz[x] = 1;
	for(int k = final[x]; k; k = e[k].next)
		if(!bz[e[k].to])
			dg(e[k].to), f[e[k].to] = x;
	for(int k = final2[x]; k; k = e2[k].next)
		if(bz[e2[k].to])
			ans[e2[k].w] = find(e2[k].to);		
}

int main() {
	Init();
	Build();
	dg(1);
	fo(i, 1, Q) printf("%d ", ans[i]);
}

轻重链剖分法

相信打过链剖的同学都会。

#include<cmath>
#include<cstdio>
#include<algorithm>
#define fo(i, x, y) for(int i = x; i <= y; i ++)
#define fd(i, x, y) for(int i = x; i >= y; i --)
#define min(a, b) ((a) < (b) ? (a) : (b))
using namespace std;

const int Maxn = 100005;
int n, x, y, Q, ans[Maxn], f[Maxn];
int final[Maxn], tot;
struct edge {
	int next, to;
}e[Maxn * 2];

int bz[Maxn], dep[Maxn], fa[Maxn], siz[Maxn], son[Maxn], top[Maxn];

void link(int x, int y) {
	e[++ tot].next = final[x], e[tot].to = y, final[x] = tot;
	e[++ tot].next = final[y], e[tot].to = x, final[y] = tot;
}


void Init() {
	scanf("%d", &n);
	fo(i, 1, n - 1) {
		scanf("%d %d", &x, &y);
		link(x, y);
	}
}

void dg(int x) {
	bz[x] = 1;
	siz[x] = 1;
	for(int k = final[x]; k; k = e[k].next) {
		int y = e[k].to; if(bz[y]) continue;
		dep[y] = dep[x] + 1;
		fa[y] = x;
		dg(y);
		siz[x] += siz[y];
		if(siz[y] > siz[son[x]]) son[x] = y;
	}
	bz[x] = 0;
}

void dg2(int x) {
	bz[x] = 1;
	if(top[x] == 0) top[x] = x;
	if(son[x] != 0) top[son[x]] = top[x], dg2(son[x]);
	for(int k = final[x]; k; k = e[k].next) {
		int y = e[k].to; if(bz[y]) continue;
		dg2(y);
	}
}

int Lca(int x, int y) {
	while(top[x] != top[y])
		if(dep[top[x]] >= dep[top[y]]) x = fa[top[x]]; else y = fa[top[y]];
	return dep[x] < dep[y] ? x : y;
}

void End() {
	scanf("%d", &Q);
	fo(i, 1, Q) {
		scanf("%d %d", &x, &y);
		printf("%d ", Lca(x, y));
	}	
}

int main() {
	Init();
	dep[1] = 1; dg(1);
	dg2(1);
	
	End();
}

时间比对：

附1000000随机数据评测结果：
这里写图片描述

多个点的lca

就是一个点到其它所有点的lca的深度最小的那一个，感性证明。

Cold_Chair
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
O(1) LCA
Sakura_Chiyo的博客
10-31 2153
基本思想 按欧拉序将子树对应映射到序列上，求lca(x,y)，pos[x]--pos[y]中深度最小的点就是答案。 具体实现 先dfs一遍，处理出深度并完成映射。 然后用st表求出区间深度最小的点。 最后回答模仿st表即可。 代码 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;string&gt; #incl...
LCA (最近公共祖先) Tarjan & 倍增
01-03
LCA Tarjan： 实现原理 理解：离线算法，建好树后再查询，一次DFS 吧所有查询解决完。 时间复杂度：O(n+q)； n个点 q次询问 补一下：链式向前星，并查集 ，Tarjan 代码 #include #include #include #include #...
c++最近公共祖先LCA
zhaoniuniu0309的博客，刚刚开始写博文的新手，有不对的地方请谅解。
07-22 1229
今天来介绍一个c++中的算法：最近公共祖先LCA。最近公共祖先是什么呢？就是给出在树上的两个节点，求出它们的最近公共祖先，也可以理解成深度最深的公共祖先。这个算法用处很大，比如我们可以用它来求任意两个节点的距离。具体后面会讲。i++){//i从1开始！= edge[now][i]){//注意！！now的儿子不能再回到now的父亲了h;i++, h >>= 1){//例如h = (1011)2，那么第一次要跳，并且跳2^1也就是2^0级。
LCA详解
热门推荐
刘伟的博客
10-18 2万+
LCA问题(least Comment Ancestors,最近公共祖先问题),是指给定一棵有根树T,给出若干个查询LCA(u,v)(通常查询数量较大)， 每次求树T中两个顶点u和v的最近公共祖先，即找到一个节点，同时是u和v的祖先，并且深度尽可能的大(尽可能远离树根). LCA问题的解法有很多，有一般解法，基于tarjan的解法，跳表解法以及RMQ和LCA互相转化的解法。下面我们依次
最近公共祖先(LCA)详解
最新发布
m0_74732859的博客
04-24 971
1.前言 公共祖先问题是指在一个树结构中，找到两个节点的最近公共祖先（Lowest Common Ancestor, LCA）。公共祖先指的是两个节点的某个祖先节点，而最近公共祖先则指的是离这两个节点最近的共同的祖先节点
LCA问题的三种求法
HJ
08-16 811
先来看一道例题： hdu 2586 How far away ？ http://acm.hdu.edu.cn/showproblem.php?pid=2586 题目描述的就是给你一棵n个节点的树，然后Q次询问，每次询问的内容是节点x和节点y的最近公共祖先（LCA） 接下来就来说一说LCA（最近公共祖先） 你需要准备的预备知识： ①ST表处理RMQ问题； ②并查集的思想以及实现； ③...
【图论】LCA（倍增）
SY奇星的OI博客
07-27 2124
LCA通常指的是“最近共同祖先”（Lowest Common Ancestor）。LCA是一种用于解决树或图结构中两个节点的最低共同祖先的问题的算法。在树结构中，LCA是指两个节点的最近层级的共同祖先节点。例如，考虑一棵树，其中节点A是节点B和节点C的祖先，而节点D是节点B和节点C的共同祖先，但节点D不是最低层级的共同祖先。在这种情况下，LCA就是节点D。LCA算法在计算机科学中有广泛的应用，例如在计算树的最近公共祖先、解决图的连通性问题、计算有向无环图（DAG）的最近公共祖先等方面。
LCA.tar.zip_二叉树的最近公共祖先问题
09-20
在计算机科学领域，二叉树的最近公共祖先（Lowest Common Ancestor，简称LCA）问题是一个经典的数据结构问题，特别是在图论和算法设计中。最近公共祖先指的是在一棵树中，两个节点的共同祖先中离叶子节点最远的一个...
二叉树最近最近公共祖先
05-15
在二叉树中，最近公共祖先（最近共同祖先，LCA，Lowest Common Ancestor）是指两个节点在树中的最近的共同父节点。在某些应用场景，如文件系统或社交网络中，找到最近公共祖先具有重要意义。 针对给定的"二叉树最近...
lca求最近公共祖先
11-15
lca用来求最近公共祖先，主要运用的是并查集的思想
codeforces E. Tree （lca 求最小公共祖先）
01-03
E. Tree Queries time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output You are given a rooted tree consisting of
8.17-8.18 倍增算法及其经典应用:RMQ+ST表、树上倍增求LCA
m0_62709362的博客
08-17 316
倍增算法及其经典应用:RMQ+ST表、树上倍增求LCA
LCA 倍增+O(1)
AnnieL
06-10 1081
LCA 倍增算法 时间复杂度为O(NlogN)O(NlogN)O(NlogN)的在线算法 Dep[v]Dep[v]Dep[v]记录节点vvv的深度，Fa[v][k]Fa[v][k]Fa[v][k]记录vvv向上第2k2k2^k个祖先的编号 代码 #include&amp;amp;amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;amp;amp;lt;cstd
最近公共祖先（LCA）
前端学习博客
01-29 1407
一.暴力解法（一） 会超时 对于点x,y。向上搜索点x节点的父节点，并将搜索到的父节点依次标记为走过，然后再搜索y节点的父节点，当搜索到第一个已经标记了的节点时，即为他们的最近的公共祖先。 题目描述 如题，给定一棵有根多叉树，请求出指定两个点直接最近的公共祖先。 输入格式 第一行包含三个正整数 N,M,SN,M,S，分别表示树的结点个数、询问的个数和树根结点的序号。 接下来 N-1N−1 行每行包含两个正整数 x, yx,y，表示 xx 结点和 yy 结点之间有一条直接连接的边（数据保证可以构成树）。 接
学习笔记-动态树Link-Cut-Tree
weixin_30443747的博客
03-09 124
--少年你有梦想吗？ --少年你听说过安利吗？ 安利一个集训队讲解：http://wenku.baidu.com/view/75906f160b4e767f5acfcedb 关于动态树问题，有多种方法。。LCT是其中比较常用的方法； LCT这种东西根本没用----by ShallWe ----你真的确定吗（charge） 我之前非常确定。 。。。。。。。。。 LCT...
洛谷 - P3379 【模板】最近公共祖先（LCA）(RMQ求LCA/Tarjan求LCA)
Falcon的博客
10-27 274
题目链接：点击查看 题目大意：给出一棵 n 个点组成的有根树，再给出 m 次询问，每次询问需要回答点 x 和点 y 的 lca 题目分析：今天新学了两种蛮有意思的求 LCA 的方法，总结一下四种方法各有利弊吧，实现复杂度参考我自己，如果有代码大佬能闭着眼随便写的话，忽略即可 Orz 树上倍增求LCA： 时间复杂度： 预处理：O( nlogn ) 查询：O( logn ) 空间复杂度：O( nlogn ) 实现复杂度：最简单 树链剖分求LCA： 时间复杂度： 预处理：O( n )
LCA最近公共祖先详解
weixin_43736492的博客
04-08 468
最近公共祖先LCA(lowest common ancestor) 在图论和计算机科学中，最近公共祖先（英语：lowest common ancestor）是指在一个树或者有向无环图中同时拥有v和w作为后代的最深的节点。在这里，我们定义一个节点也是其自己的后代，因此如果v是w的后代，那么w就是v和w的最近公共祖先。 最近公共祖先是两个节点所有公共祖先中离根节点最远的，计算最近公共祖先和根节点的长度...
RMQ求LCA
蒟蒻 lxw的博客
10-23 255
题目链接：https://www.luogu.org/problem/P3379 学习链接：https://blog.csdn.net/Diogenes_/article/details/81412316 预处理时间复杂度O(NlogN) 查询时间复杂度O(1) #include <bits/stdc++.h> #define rep(i, a, b) for(int ...
trajan算法求lca 超级详细配图讲解
m0_50219534的博客
10-11 608
关于离线算法 （下面内容可以略过。） 离线算法其实就是将多个询问一次性解决。离线算法往往是与在线算法相对的。例如求LCA的算法中，树上倍增属于在线算法，在对树进行O(n)O(n)O(n)预处理后，每个询问用O(log2n)O(log_2n)O(log2​n)复杂度回答。而离线的Tarjan算法则是用O(n+q)O(n+q)O(n+q)时间将询问一次性全部回答。 详解 下面是一棵树，我们将以这棵树为例子讲解Tarjan算法，其中0号点为根。 假设对于这棵树的询问有4个，分别询问： LCA(2,8)LCA(2

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值