LCA

原创 于 2020-01-14 20:48:37 发布 · 287 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了如何使用倍增法求解最近公共祖先（LCA）问题，包括预处理阶段如何通过深度优先搜索（DFS）计算每个节点的各级祖先，以及查询阶段如何快速定位两个节点的最近公共祖先。通过递归分解和跳跃技巧，实现高效的LCA查询算法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

LCA
本 篇 博 客 讲 解 的 是 倍 增 求 L C A 的 方 法 本篇博客讲解的是倍增求LCA的方法 本篇博客讲解的是倍增求LCA的方法
对 于 一 颗 树 ， 我 们 先 给 每 个 点 求 出 各 级 祖 先 对于一颗树，我们先给每个点求出各级祖先 对于一颗树，我们先给每个点求出各级祖先

void dfs(int ss,int fath){
	depth[ss]=depth[fath]+1;
	if(ss!=s)fa[ss][0]=fath;//赋初值
	for(int i=1;i<=lg[depth[ss]];i++){
		fa[ss][i]=fa[fa[ss][i-1]][i-1];//可以画一棵树看看，发现ss的第i-1级祖先的i-1级祖先即为ss的第i祭祖先
	}
	for(int i=head[ss];i;i=q[i].link){
		int v=q[i].v;
		if(v==fath) continue;
		dfs(v,ss);
	}
}

LCA的求法：

int Lca(int x,int y){
	if(depth[x]<depth[y]) swap(x,y);
	while(depth[x]>depth[y]){
		x=fa[x][lg[depth[x]-depth[y]]];//即x最多只能跳2^log2(depth[x]-depth[y])级祖先，最多depth[x]-depth[y]步
	}
	if(x==y) return x;
	for(int j=lg[depth[x]-1];j>=0;j--){
		if(fa[x][j]!=fa[y][j]){
			x=fa[x][j],y=fa[y][j];//因为x，y的深度相同，所以x，y到lca跳的距离应该是一样的，即一定存在fa[x][j]==fa[y][j],同理，往上跳了之后深度还是一样的，一直跳下去
		}
	}
	return fa[x][0];
}

AC代码

#include<bits/stdc++.h>
using namespace std;

const int N=5e5+5;
int n,m,s,cnt=0,head[N];
struct edge{
	int link,v;
}q[N<<1];
void put(int x,int y){
	q[++cnt].v=y;
	q[cnt].link=head[x];
	head[x]=cnt;
}
int depth[N],lg[N],fa[N][20];
void dfs(int ss,int fath){
	depth[ss]=depth[fath]+1;
	if(ss!=s)fa[ss][0]=fath;
	for(int i=1;i<=lg[depth[ss]];i++){
		fa[ss][i]=fa[fa[ss][i-1]][i-1];
	}
	for(int i=head[ss];i;i=q[i].link){
		int v=q[i].v;
		if(v==fath) continue;
		dfs(v,ss);
	}
}
int Lca(int x,int y){
	if(depth[x]<depth[y]) swap(x,y);
	while(depth[x]>depth[y]){
		x=fa[x][lg[depth[x]-depth[y]]];
	}
	if(x==y) return x;
	for(int j=lg[depth[x]-1];j>=0;j--){
		if(fa[x][j]!=fa[y][j]){
			x=fa[x][j],y=fa[y][j];
		}
	}
	return fa[x][0];
}
int main(){
	scanf("%d%d%d",&n,&m,&s);
	for(int i=1;i<n;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		put(u,v),put(v,u);
	}
	lg[1]=0;
	for(int i=2;i<=n;i++){
		lg[i]=lg[i>>1]+1;
	}
	dfs(s,0);
	while(m--){
		int u,v;
		scanf("%d%d",&u,&v);
		int lca=Lca(u,v);
		printf("%d\n",lca);
	}
}
SAS+proc lca浅类别分析安装程序
09-16
其中，PROC LCA（Latent Class Analysis）是SAS中的一个过程，用于执行潜在类别分析，这是一种统计方法，旨在从观测数据中识别出隐藏的、不可见的类别结构。PROC LCA尤其适用于处理多分类变量，它可以帮助研究人员...
LCA-AW2.2.zip
04-09
【LCA词汇复杂度分析软件】是一款用于自然语言处理（NLP）的专业工具，它主要聚焦于语言的复杂度分析。LCA，全称为“Language Complexity Analysis”，此软件旨在帮助用户理解和评估文本的语言难度，这对于教育、...
日立LCA电气图纸(K3500490).pdf
06-24
这导致无法从中提取任何有关“日立LCA电气图纸(K3500490).pdf”文件的知识点。为了满足题目要求，我将基于标题和描述部分提供的信息，对“日立LCA电气图纸”进行知识性的解释。 ### LCA型微机控制变压变频调速无...
openLCA:适用于LCA的专业开源软件-开源
04-28
标题中的“openLCA”指的是一个专业开源的生命周期评估（Life Cycle Assessment，简称LCA）软件，它专门用于进行环境影响分析和可持续性评估。开源软件意味着它的源代码是公开的，用户可以自由地查看、修改和分发，...
LatentClassPlots:从 R 中的 Mplus LCA 输出绘制响应概率图
06-10
LatentClassPlots 是一个 R 函数，旨在从 Mplus 中估计的潜在类分析 (LCA) 中绘制响应概率图。 参数 要从 LCA 输出绘制图，唯一需要的参数是data参数。 提供这一点将导致使用附加参数的预设的绘图。 第二个参数 ( ...
在线LCA
最新发布
06-21
<think>首先，用户的问题是关于在线LCA（最近公共祖先）算法的实现。我需要参考系统级指令和用户可见层的规则来构建回答。系统级指令：-所有行内数学表达式用$...$格式，例如：$x^2$。-独立公式用$$...$$格式并单独成段。-LaTeX语法必须正确。-使用中文回答。-生成相关问题。-回答中引用的段落末尾自然地添加引用标识，例如：[^1]。用户可见层：-回答结构清晰，帮助用户逐步解决问题。-尽量保证回答真实可靠。-参考站内引用：引用[1]和引用[2]是关于LCA的，但它们是示例引用，我需要基于真实知识回答。用户的问题是：“我想查找关于在线LCA（最近公共祖先问题）的算法或实现请问在线最近公共祖先LCA算法实现”所以，我需要解释在线LCA算法的实现。在线算法意味着程序可以逐个处理查询，而不需要所有输入一开始就给出。关键点：-在线LCA通常使用倍增法（BinaryLifting）实现。-这与引用[2]提到的相似：存储每个节点的第$2^j$个祖先。-引用[1]定义了在线算法：程序可以序列化处理输入。我的回答应该包括：1.解释什么是在线LCA算法。2.描述倍增法的实现步骤。3.提供伪代码或代码示例。4.添加引用标识（如果适用）。5.在末尾生成相关问题。结构回答：-先介绍在线LCA。-逐步解释算法。-给出实现代码（用代码块）。-最后生成相关问题。使用中文回答。数学表达式：-行内：例如，节点深度$depth[u]$。-独立公式：如果需要，比如公式。引用：-引用[1]和[2]是提供的，我可以自然地引用它们，因为它们相关。-例如，在解释倍增法时，引用[2]。实现细节：-倍增法：-预处理：存储每个节点的祖先数组。-查询：通过二进制提升找到LCA。-步骤：1.预处理树的深度和祖先信息。2.对于每个查询(u,v)，调整到相同深度，然后一起向上跳。伪代码：-初始化祖先数组。-查询函数。生成相关问题：-类似于示例，生成3-4个相关问题。完整回答框架：1.解释在线LCA：在线算法允许逐个处理查询，而不需要所有查询输入一开始就给出。2.描述倍增法实现：-预处理：DFS遍历树，计算深度和直接父节点。-构建祖先表：对于每个节点和每个j（0到max_depth），存储$anc[i][j]$表示节点i的第$2^j$个祖先。-查询：将两个节点升到相同深度，然后逐步向上跳。3.提供代码示例（用Python或类似语言）。4.引用：[^1]用于在线算法定义，[^2]用于倍增法实现。5.生成相关问题。确保LaTeX正确：-行内：$depth[u]$,$2^j$-独立：如果有公式，如$$\text{LCA}(u,v)=\text{...}$$，但可能不需要。代码块：使用```language```格式。最终，生成相关问题：例如：1.在线LCA算法的复杂度分析？2.如何优化倍增法？3.在线LCA的应用场景？</think>### 在线最近公共祖先（LCA）算法实现 在线最近公共祖先（LCA）算法用于在有根树中快速回答查询，即给定两个节点$u$和$v$，找到它们最近的公共祖先。在线算法的核心特点是它可以逐个处理查询输入，而无需预先知道所有查询[^1]。这与离线算法（如Tarjan算法）不同，后者需要一次性加载所有查询。在线LCA的常用实现是**倍增法（Binary Lifting）**，它通过预处理树的祖先信息来高效支持查询。下面我将逐步解释算法原理并提供代码实现。 #### 算法原理 倍增法的核心思想是预处理每个节点的$2^j$级祖先（即节点向上跳$2^j$步的祖先），从而在查询时通过二进制提升快速调整节点深度并找到LCA。算法分为两个阶段： 1. **预处理阶段**： - 通过DFS遍历树，计算每个节点的深度$depth[u]$和直接父节点（即$2^0$级祖先）。 - 构建一个祖先表$anc$，其中$anc[u][j]$存储节点$u$的第$2^j$个祖先。利用动态规划：$anc[u][j] = anc[ anc[u][j-1] ][j-1]$（当$j \geq 1$时）[^2]。 2. **查询阶段**： - 给定查询$(u, v)$，先将较深的节点向上跳到与另一个节点相同深度（使用二进制提升）。 - 然后，两个节点一起向上跳，直到它们的祖先相同。具体地，从最大$j$开始尝试跳跃，如果跳跃后祖先不同才执行跳跃。 算法的时间复杂度： - 预处理：$O(n \log n)$，其中$n$是节点数。 - 单次查询：$O(\log n)$。 空间复杂度：$O(n \log n)$。 #### 实现代码 以下是用Python实现的倍增法在线LCA算法。代码包括树的构建、预处理和查询函数。假设树以邻接表形式存储，节点编号从1开始。 ```python import math from collections import defaultdict, deque class LCA: def __init__(self, n, root=1): self.n = n self.root = root self.graph = defaultdict(list) self.depth = [0] * (n + 1) self.anc = defaultdict(lambda: [0] * (self.max_j + 1)) # 祖先表 def add_edge(self, u, v): """添加树边""" self.graph[u].append(v) self.graph[v].append(u) def preprocess(self): """预处理：计算深度和祖先表""" # 初始化最大跳跃指数 max_j = floor(log2(n)) self.max_j = math.floor(math.log2(self.n)) + 1 # BFS计算深度和直接父节点 queue = deque([self.root]) self.depth[self.root] = 1 parent = [0] * (self.n + 1) # 直接父节点 while queue: u = queue.popleft() for v in self.graph[u]: if v == parent[u]: continue parent[v] = u self.depth[v] = self.depth[u] + 1 queue.append(v) # 构建祖先表 anc[u][j] for j in range(self.max_j + 1): for i in range(1, self.n + 1): if j == 0: self.anc[i][j] = parent[i] # 2^0 = 1级祖先 else: prev = self.anc[i][j - 1] self.anc[i][j] = self.anc[prev][j - 1] if prev != 0 else 0 def query(self, u, v): """在线查询LCA(u, v)""" # 确保u较深，否则交换 if self.depth[u] < self.depth[v]: u, v = v, u # 将u跳到与v相同深度 diff = self.depth[u] - self.depth[v] j = 0 while diff: if diff & 1: # 二进制位为1时跳跃 u = self.anc[u][j] diff //= 2 j += 1 # 如果此时u和v相同，则v是LCA if u == v: return u # 一起向上跳，直到祖先相同 for j in range(self.max_j, -1, -1): if self.anc[u][j] != self.anc[v][j]: u = self.anc[u][j] v = self.anc[v][j] return self.anc[u][0] # LCA是u的直接父节点 # 示例用法 if __name__ == "__main__": # 构建树: 节点数n=5, 根节点为1 lca = LCA(n=5, root=1) edges = [(1, 2), (1, 3), (2, 4), (2, 5)] # 树边 for u, v in edges: lca.add_edge(u, v) lca.preprocess() # 预处理 # 在线查询示例 print(lca.query(4, 5)) # 输出: 2 (LCA of 4 and 5 is 2) print(lca.query(3, 4)) # 输出: 1 (LCA of 3 and 4 is 1) ``` #### 关键说明 - **在线处理**：此实现允许逐个添加查询（如`query(4, 5)`），无需预先知道所有查询，符合在线算法定义[^1]。 - **优化**：使用BFS代替DFS避免递归深度限制；二进制提升减少跳跃次数。 - **适用场景**：适用于动态查询环境，如实时网络路由或游戏AI中的路径查找。 如果您有特定树结构或查询序列，我可以帮助调整代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值