树上问题（一）倍增算法求最近公共祖先

最新推荐文章于 2024-06-26 20:02:56 发布

u一枚蒟蒻

最新推荐文章于 2024-06-26 20:02:56 发布

阅读量565

点赞数 8

分类专栏： OI 文章标签：图论算法树结构

本文链接：https://blog.csdn.net/u010141779/article/details/120825878

版权

OI 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

本文介绍了如何利用倍增思想优化最近公共祖先(LCA)的计算，通过预处理节点深度和与指定距离的祖先节点关系，将原本的逐层遍历提升为幂次级的效率提升。通过递推计算与节点距离的2的幂次方祖先，大大减少了查找LCA的时间复杂度。

摘要由CSDN通过智能技术生成

倍增算法求最近公共祖先

一、概述

在图论和计算机科学中，最近公共祖先 LCA(Least Common Ancestors)是指在一个树或者有向无环图中同时拥有v和w作为后代的最深的节点。在这里，我们定义一个节点也是其自己的后代，因此如果v是w的后代，那么w就是v和w的最近公共祖先。 --维基百科

在这里插入图片描述

上图中， $L C A (11, 8) = 8$ ， $L C A (11, 9) = 1$ ， $L C A (7, 8) = 2$ 。求 $L C A$ 有很多算法，比如倍增算法，Tarjan(离线)算法，与RMQ问题的转换等。

二、朴素算法

求 $L C A (v, w)$ 比较直观想法是，先将 $v$ ， $w$ 中层次较深者提升到同一深度，然后一起一步一步向上爬，直到相遇，相遇节点则为 $L C A (v, w)$ 。
如下图，求 $L C A (11, 9)$ 时，先将较深节点 $11$ 提升到其祖先节点 $8$ ，此时，求 $L C A (11, 9)$ 相当于求 $L C A (8, 9)$ ，然后节点 $8$ 和 $9$ 再沿着其祖先链一步一步向上爬。整个过程为， $L C A (11, 9)$ = $L C A (8, 9)$ = $L C A (5, 6)$ = $L C A (2, 3)$ = $1$ 。
在这里插入图片描述

需要注意，如果 $v$ ， $w$ 之间存在祖先关系，比如求 $L C A (8, 11)$ ，节点 $11$ 提升到节点 $8$ 时就已经相遇了，就不需要后面步骤了。
代码如下：

#include<bits/stdc++.h>
using namespace std;
// 最多节点数
const int maxn = 500005;
// n ： 节点数
// s ： 根节点编号
// fa[i] ： 节点i父节点编号
// depth[i] ：节点i深度
int n, s, head[maxn], fa[maxn], depth[maxn], m, v, w, cnt;
struct E{
	int to, next;
} edge[2*maxn];

// 链式向前星存树模板代码
void add_edge(int from, int to){
	edge[cnt].to = to;
	edge[cnt].next = head[from];
	head[from] = cnt++;
}
// 深度优先搜索, 预处理每个节点深度和父节点编号
// r ： 当前根节点编号
// p ： r节点父节点编号
void dfs(int r, int p){
	// 当前节点深度为父节点深度+1
	depth[r] = depth[p]+1;
	fa[r] = p;
	// 递归到子树
	for(int i = head[r]; i != -1; i = edge[i].next){
		int to = edge[i].to;
		if(to != p){
			dfs(to, r);
		}
	}
}

int main(){
	memset(head, -1, sizeof(head));
	cin>>n>>s;
	for(int i = 0; i < n-1; i++){
		cin>>v>>w;
		add_edge(v, w);
		add_edge(w, v);
	}
	dfs(s, -1);
	cin>>v>>w;
	// 确保depth[v] >= depth[w]， 即节点v是深度较深节点
	if(depth[v] < depth[w]) swap(v, w);
	// 节点v一步一步向上爬到和节点w同深度
	while(depth[v] > depth[w]) v = fa[v];
	// 节点v和节点w一步一步沿着父节点向上爬, 直到相遇
	// 如果节点v和节点w之间具有祖先关系, 则通过上一个while循环后这里v等于w，不会进入这个循环
	while(v != w){
		v = fa[v];
		w = fa[w];
	}
	cout<<v<<endl;
}

神马，这就完了吗？说好的倍增呢？
前文已经说了，这只是一个直观想法，其实这个算法可以进行优化的。
这个算法中有两个向上一步一步爬的地方：

节点 $v$ 沿着父节点一步一步向上爬到和节点 $w$ 同深度；
节点 $v$ 和节点 $w$ 沿着各自的父节点一步一步向上爬直到他们相遇；

这样一步一步向上爬是不是感觉很费经？有没有更高效的算法呢？

三、用倍增优化

接下来就是我们主角倍增上场了。

1. 倍增思想

我们知道任何一个正整数都可以用 $2$ 的幂次方之和表示，相当于将这个数转化成 $2$ 进制。那么在向上爬的过程中可不可以一次爬 $2$ 的幂次方步长，即一次爬 $2^0$ ， $2^1$ ， $2^2$ ， $2^3$ ， $2^4$ … $2^{30}$ 这些步长，这样最多向上爬 $30$ 次左右。比如 $7=2^2+2^1+2^0$ ，我们只需要爬三步，这三步步长分别为 $1$ ， $2$ ， $4$ ，这样效率呈幂次方提升，这就是倍增；
但是，这里还有一个关键问题，不知道总共需要爬多少步，那怎么用 $2$ 的幂次方之和表示，总不能每个 $2$ 的幂次方都爬吧。
比如总共需要爬 $5$ 步， $2^0+2^1+2^2+2^3=1+2+4=7>5$ ，已经爬过了，还得回溯。

2. 实现

虽然不知道总共需要爬多少步，但是知道一个步长能不能爬。

对于第一种情况，在节点 $v$ 向上爬到和节点 $w$ 同深度过程中，如果爬了这一步发现其深度小于 $w$ 深度，则这一步不能爬；
例如上面这棵树， $v = 11$ ， $w = 2$ 时， $d e p t h [v] = 6$ ， $d e p t h [2] = 6$ ，对于一步长度为 $2^4=16$ 时，如果爬了这步， $d e p t h [v] = 6 - 16 = - 10 < 2$ ，所以这步不能爬，但是，如果步长为 $2^2=4$ 时，如果爬了这步， $d e p t h [v] = 6 - 4 = - 10 = 2$ ，这一步可以爬。
对于第二种情况，节点 $v$ 和节点 $w$ 沿着各自的祖先节点向上爬时，如果爬了这一步还没有到达公共祖先则能爬，否则这一步不能爬。我们的策略是要把公共祖先之前的所有步爬完，最后都停留在公共祖先前一步，那再爬一步 $2^0=1$ 就到达最近公共祖先。

例如上面这棵树， $v = 4$ ， $w = 5$ 时，对于步长 $2^1=2$ ，如果爬了这一步则 $v = 1$ ， $w = 1$ ，爬到公共祖先上，这一步不能爬。但是对于步长 $2^0=1$ ，爬了这一步后 $v = 2$ ， $w = 2$ ，相遇了，也不能爬这一步。
知道了一个步长能不能爬有什么好处呢？
我们联想我们平时怎么把一个十进制数转换成二进制的，当然我们可以使用除二取余倒排数这种方法来做，我们还可以试减这种方法，例如对于 $11$ ，我们可以从一个最接近 $11$ 但小于等于 $11$ 的一个 $2$ 的幂次方的数开始向下试减，不断重复，使其最终减为零；比如 $11$ 可以减掉 $2^3=8$ ，不能减掉比 $2^3$ 更大的 $2$ 的幂次方，所以 $11=2^3+5$ ， $5$ 可以减掉 $2^2=4$ ，所以 $11=2^3+2^2+1$ ， $1$ 只能减掉 $2^0=1$ ，所以 $11=2^3+2^2+2^0$ 。
这里能不能减掉一个 $2$ 的幂次方，是不是就是上面的一个步长为 $2$ 的幂次方步能不能走，可以借鉴这种思想。

对于第一种情况，我们是知道 $v$ 是要向上走 $d e p t h [w] - d e p t h [v]$ 步的，所以我们可以从步长最接近 $d e p t h [w] - d e p t h [v]$ 但小于等于 $d e p t h [w] - d e p t h [v]$ $2$ 的幂次方即 $2$ 的 $\lfloor log _{2}^{depth[w]-depth[v]} \rfloor$ 次方步开始向下试走，最终必定走到和 $w$ 同深度。
在这里插入图片描述
例如上图是一个特殊例子， $v = 10$ 和 $w = 1$ 具有祖先关系， $d e p t h [w] - d e p t h [v] = 9$ ， $\lfloor log _{2}^{9} \rfloor=3$ ，所以从步长为 $2^3=8$ 开始试走，先走一步 $2^3$ 到达节点 $2$ ，此时 $d e p t h [w] - d e p t h [v] = 1$ ， $2^2=4 >1$ 不能走， $2^1=2 >1$ 不能走， $2^0=1 =1$ 走完这步后和节点 $w$ 同深度。
对于第二种情况，节点 $v$ 和节点 $w$ 沿着各自的祖先节点向上爬，我们并不知道需要向上爬多少步，但步数肯定小于 $d e p t h [v]$ 或者 $d e p t h [w]$ ，所以我们可以从步长为 $2$ 的 $\lfloor log _{2}^{depth[v]-1} \rfloor$ 的步开始试走；
在这里插入图片描述
例如上图， $v = 18$ 和 $w = 19$ ， $d e p t h [18] = d e p t h [19] = 11$ ， $\lfloor log _{2}^{11-1} \rfloor=3$ ，但 $v$ 和 $w$ 如果沿着各自祖先链向上爬步长为 $2^3=8$ 一步后，在节点 $3$ 相遇了，所以 $2^3=8$ 这一步不能爬； $v$ 和 $w$ 向上爬步长为 $2^2=4$ 一步后， $v = 10$ 和 $w = 11$ ，未相遇，这一步可以走；然后判断步长为 $2^1=2$ 这步能不能爬，爬了这一步后 $v = 6$ 和 $w = 7$ ，未相遇，这一步可以走；最后判断步长为 $2^0=1$ 这步能不能爬，爬了这一步后 $v = 4$ 和 $w = 5$ ，未相遇，这一步可以走；最终， $v$ 和 $w$ 都到公共祖先链的下一个节点，在向上走步长为 $1$ 的一步后到达最近公共祖先节点。

3. 算法核心

要实现该算法，这里有出现了两个难题：

对于节点 $v$ ，距离为 $2$ 的幂次方的祖先节点编号怎么求，从节点 $v$ 出发，沿着祖先链走一步步长为 $2$ 的幂次方的步就到达了该节点，这可以说是倍增核心；
对于任意距离 $d$ ， $\lfloor log _{2}^{d} \rfloor$ 怎么求；

对于第一个问题，我们之前是使用 $f a [i]$ 数组记录节点 $i$ 父节点的，并在从父节点递归到子节点时记录子节点的 $f a []$ ，类似于递推。但是现在不仅要记录节点 $i$ 的父节点，还要记录与其距离为 $2^1$ ， $2^2$ ， $2^3$ ， $2^4$ … 的祖先节点，所以将 $f a []$ 定义成以为数组肯定不够用，需要将其定义为二维数组 $f a [i] [j]$ ，表示与节点 $i$ 相聚 $2^j$ 的祖先节点编号， $f a [i] [0]$ 和原来 $f a [i]$ 相同，存储节点 $i$ 直接父节点。那 $f a [i] [j]$ 怎么求呢？

在这里插入图片描述

如上图，对于节点 $10$ ， $d e p t h [10] = 10$ ， $\lfloor log _{2}^{10-1} \rfloor=3$ ，只需要求 $f a [10] [0]$ ， $f a [10] [1]$ ， $f a [10] [2]$ ， $f a [10] [3]$ 。例如， $f a [10] [3] = f a [6] [2] = 2$ ，看出什么端倪出来没？大概什么意思呢， $2^j=2^{j-1}+2^{j-1}$ ，就是说如果要从节点 $i$ 跳到距离为 $2^j$ 的祖先节点，可以先跳到距离为 $2^{j-1}$ 次方的中间节点节点，再从这个节点出发跳一步 $2^{j-1}$ 就到了距离 $i$ 为 $2^j$ 的祖先节点。与节点 $i$ 距离为 $2^{j-1}$ 次方的中间节点节点是不是就是 $f a [i] [j - 1]$ ，在从这个几点出发跳一步 $2^{j-1}$ 是不是就是 $f a [f a [i] [j - 1]] [j - 1]$ ，所以 $f a [i] [j]$ 可以通过 $f a [f a [i] [j - 1]] [j - 1]$ 递推。

对于第二个问题，我们可以用递推。假设数组 $l g [i]$ 存值为 $\lfloor log _{2}^{i} \rfloor$ ，那么在知道 $l g [i - 1]$ 情况下如何推出 $l g [i]$ ？
对于 $i$ 如果可以刚好表示成 $2$ 的幂次方，那么 $i - 1$ 就不能表示成 $2$ 的幂次方， $l g [i]$ 需要将 $l g [i - 1]$ 向下取整部分收为 $1$ ，即 $l g [i] = l g [i + 1] + 1$ ；如果 $i$ 不能表示成 $2$ 的幂次方，则直接 $l g [i] = l g [i + 1]$ 。但是 $i$ 是不是 $2$ 的幂次方也不好确认，我们可以这样，让lg[i]存 $\lfloor log _{2}^{i} \rfloor+1$ ，在推 $l g [i]$ 时，我们看下 $2^{lg[i-1]}$ 是不是等于 $i$ ，如果相等说明进入刚好遇到 $2$ 的幂次方，需要 $+ 1$ ， $2$ 的幂次方可以通过位右移可以很快算出来。
代码如下：

for(int i = 1; i <= n; ++i){
	lg[i] = lg[i-1] + (1 << lg[i-1] == i); 
}
for(int i = 1; i <= n; ++i) lg[i]--;

OK，所有问题搞定，直接上代码：

#include<bits/stdc++.h>
using namespace std;
// 最多节点数
const int maxn = 500005;
// fa[i][j] : 与节点i相距2的j次方的祖先节点编码
// depth[i] : 节点i深度
// lg[i] : lg2(i) 向下取整 
// n : 节点数
// s : 根节点编号 
int head[maxn], fa[maxn][32], depth[maxn],lg[maxn], cnt=0, n, s;
// 链式向前星存树模板代码
struct E {
	int to, next;
} edge[maxn << 1];
void add(int from, int to) {
	edge[cnt].to = to;
	edge[cnt].next = head[from];
	head[from] = cnt++;
}
void dfs(int r, int p) {
	depth[r] = depth[p] + 1;
	// 直接父节点， 
	fa[r][0] = p;
	// 递推，把与节点i相距2的1次方到2lg[depth[r]]祖先节点编码全部推出
	for(int i = 1; i <= lg[depth[r]-1]; ++i)
		// 倍增核心代码
		fa[r][i] = fa[fa[r][i-1]][i-1];
	// 递归到子树 
	for(int i = head[r]; i != -1; i = edge[i].next)
		if(edge[i].to != p) 
			dfs(edge[i].to, r);

}
int LCA(int u, int w) {
	if(depth[u] < depth[w]) swap(u, w);
	// 倍增让u跳到和w同深度 
	while(depth[u] > depth[w]) 
		u = fa[u][lg[depth[u]-depth[w]]];
	if(u == w) return w;
	// 倍增让u和w LCA前的距离跳2完 
	for(int k = lg[depth[u]]; k >= 0; --k)
		if(fa[u][k] != fa[w][k])
			u = fa[u][k], w = fa[w][k];
	// 再跳一步到LCA 
	return fa[u][0];
}
int main() {
	memset(head, -1, sizeof(head));
	cin>>n>>s;
	int x, y;
	for(int i = 1; i <= n-1; ++i) {
		cin>>x>>y;
		add(x, y);
		add(y, x);
	}
	for(int i = 1; i <= n; ++i)
		lg[i] = lg[i-1] + (1 << lg[i-1] == i);
	for(int i = 1; i <= n; ++i) lg[i]--;
	dfs(s, 0);
	cin>>x>>y;
	cout<<LCA(x, y)<<endl;
	return 0;
}

4. 时间复杂度分析

函数dfs(int r, int p)需要递归到每个节点时间复杂度为 $O (n)$ ，对每个节点需要求与其相距 $2$ 的幂次方祖先节点编号时间复杂度 $O (l g n)$ ，所以这个函数总时间复杂度 $O (n l g n)$ 。LCA(int u, int w)函数时间复杂度为 $O (l g n)$ ，所以总时间复杂度为 $O (n l g n)$ ；