LCA之倍增算法模板

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
using namespace std;
const int maxx=500010;
int be[maxx],ne[maxx*2],to[maxx*2],e=0;
int deep[maxx],f[maxx][19],n,q,root,lim;
bool p[maxx];
void add(int x,int y){
	to[++e]=y;
	ne[e]=be[x];
	be[x]=e;
}
int read(){
	char c;
	while((c=getchar())<'0' || c>'9');
	int u=c-'0';
	while((c=getchar())>='0' && c<='9')u=u*10+c-'0';
	return u;
}
void build(int x){
	for(int i=be[x];i;i=ne[i]){
		int go=to[i];
		if(!p[go]){
			p[go]=1;
			deep[go]=deep[x]+1;
			lim=max(lim,deep[go]);
			f[go][0]=x;
			build(go);
		}
	}
}
void work(){
	for(int i=1;i<=lim;i++)
		for(int j=1;j<=n;j++){
			f[j][i]=f[f[j][i-1]][i-1];
//	printf("%d~%d~%d\n",j,i,f[j][i]);
		}
}
void lca(int x,int y){
	if(deep[x]>deep[y])swap(x,y);
	for(int i=lim;i>=0;i--)
		if(deep[f[y][i]]>=deep[x])
			y=f[y][i];
	if(x==y)printf("%d\n",x);
	else{
//		printf("x=%d~y=%d\n",x,y);
		for(int i=lim;i>=0;i--)
			if(f[x][i]!=f[y][i])
				x=f[x][i],y=f[y][i];
	printf("%d\n",f[x][0]);
	}
}
int main(){
#ifndef ONLINE_JUDGE
	freopen("input.in","r",stdin);
	freopen("output.out","w",stdout);
#endif
	int i,j,k,m;
	n=read();
	q=read();
	root=read();
	for(i=1;i<n;i++){
		j=read();
		k=read();
		add(j,k);
		add(k,j);
	}
	deep[root]=1;
	p[root]=1;
	build(root);
//	for(i=1;i<=n;i++)	printf("%d~0~%d\n",i,f[i][0]);
	lim=log(lim)/log(2);
//	cout<<lim<<"$"<<endl;
	work();
	while(q--){
		j=read();
		k=read();
		lca(j,k);
	}
return 0;
}

### LCA 倍增算法 Python 实现 LCA (Lowest Common Ancestor) 的倍增算法是一种高效求解树上最近公共祖先的方法。该方法利用动态规划的思想预先处理节点之间的关系,从而可以在 O(log n) 时间复杂度内查询任意两个节点的最近公共祖先。 #### 预处理阶段 预处理的核心在于构建 `dp` 数组,其中 `dp[i][j]` 表示从节点 i 出发向上走 \(2^j\) 步到达的父亲节点编号: ```python from collections import defaultdict, deque def preprocess(n, adj_list, root=0): logn = max(1, int(math.log2(n)) + 1) dp = [[-1]*logn for _ in range(n)] depth = [0] * n def dfs(u, parent=-1): dp[u][0] = parent if parent != -1: depth[u] = depth[parent] + 1 for j in range(1, logn): if dp[u][j-1] != -1: dp[u][j] = dp[dp[u][j-1]][j-1] for v in adj_list[u]: if v == parent: continue dfs(v, u) dfs(root) return dp, depth ``` 此部分实现了对输入图结构的遍历以及 `dp` 和 `depth` 数组初始化[^1]。 #### 查询阶段 对于每次询问 `(u,v)` ,先将两者的深度调整一致再逐步提升直到两者相遇: ```python def lca_query(dp, depth, u, v): if depth[u] < depth[v]: u, v = v, u diff = abs(depth[u]-depth[v]) while diff > 0: k = int(math.log2(diff)) u = dp[u][k] diff -= pow(2,k) if u == v: return u for k in reversed(range(len(dp[0]))): if dp[u][k]!=-1 and dp[u][k]!=dp[v][k]: u = dp[u][k] v = dp[v][k] return dp[u][0] ``` 上述代码片段展示了如何基于已有的 `dp` 及 `depth` 数据来快速定位给定两点间的最低共同祖先节点。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值