LCA(Lowest Common Ancestor)

LCA(Lowest Common Ancestor)

定义

在树上取两点 x,yx,y,他们的 LCA 为距离他们最近的公共祖先。

本章主要讲的是倍增求 LCA。

暴力求取

  1. 从 xx 开始向上移动到根结点,并标记沿途结点。
  2. 从 yy 开始向上移动到根结点,第一个被标记的就是 xx 和 yy 的 LCA。

倍增求 LCA

从任意点对 (x,y)(x,y) 移到 xx 和 yy 的 LCA 的距离可拆分为 22 的幂的和。

若预处理任意点 xx 移动 22 的幂步所到达的结点编号,则不超过 \log_2{n}log2​n 次即可找到 LCA。

具体实现

first:预处理倍增 DP

定义状态 dp_{i,j}dpi,j​ 表示点 ii 向上移动 2^j2j 步到达的结点编号。

状态转移方程:枚举 jj 从 11 到 \log_2 nlog2​n,dp_{i,j}=dp_{dp_{i,j-1},j-1}dpi,j​=dpdpi,j−1​,j−1​。

初始状态:dp_{i,0}=fa_idpi,0​=fai​。

代码片段
void pre_lca(int cur, int fa)
{
	dep[cur]=dep[fa]+1;
	dp[cur][0]=fa;
	for(int i=1;(1<<i)<=dep[cur];i++)
	{
		dp[cur][i]=dp[dp[cur][i-1]][i-1];
	}
	for(int nxt:nbr[cur])
	{
		if(nxt!=fa)pre_lca(nxt,cur);
	}
}
second:处理单次询问

第一步:约定深度较大的点,若 dep_x>dep_ydepx​>depy​,交换 xx 和 yy。

第二步:将深度较大的结点 yy 倍增向上跳至深度等于 xx。

第三步:判断 xx 是否等于 yy。若已经相等则 xx 为 LCA,停止寻找。

第四步:xx 和 yy 一起倍增向上跳,只要 xx 和 yy 不重合。

第五步:xx 向上一步即为 LCA。

代码片段
int lca(int x, int y)
{
	if(dep[y]<dep[x])swap(x,y);
	for(int i=20;i>-1;i--)
	{
		if(dep[dp[y][i]]>=dep[x])
		{
			y=dp[y][i];
		}
	}
	if(x==y)return x;
	for(int i=20;i>-1;i--)
	{
		if(dp[x][i]!=dp[y][i])
		{
			x=dp[x][i],y=dp[y][i];
		}
	}
	return dp[x][0];
}

时间复杂度

预处理是 O(n \log_2 n)O(nlog2​n) 的,中间单次求取仅为 O(n)O(n)

模板代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
int dp[500005][21],dep[500005], n, m, s;
vector<int> nbr[500005];
void pre_lca(int cur, int fa)
{
	dep[cur]=dep[fa]+1;
	dp[cur][0]=fa;
	for(int i=1;(1<<i)<=dep[cur];i++)
	{
		dp[cur][i]=dp[dp[cur][i-1]][i-1];
	}
	for(int nxt:nbr[cur])
	{
		if(nxt!=fa)pre_lca(nxt,cur);
	}
}
int lca(int x, int y)
{
	if(dep[y]<dep[x])swap(x,y);
	for(int i=20;i>-1;i--)
	{
		if(dep[dp[y][i]]>=dep[x])
		{
			y=dp[y][i];
		}
	}
	if(x==y)return x;
	for(int i=20;i>-1;i--)
	{
		if(dp[x][i]!=dp[y][i])
		{
			x=dp[x][i],y=dp[y][i];
		}
	}
	return dp[x][0];
}
signed main()
{
	ios::sync_with_stdio(0),cin.tie(0);
	cin>>n>>m>>s;
	for(int i=1;i<n;i++)
	{
		int x, y;
		cin>>x>>y;
		nbr[x].push_back(y);
		nbr[y].push_back(x);
	}
	pre_lca(s,0);
	for(int i=1;i<=m;i++)
	{
		int x, y;
		cin>>x>>y;
		cout<<lca(x,y)<<"\n";
	}
}

LCA 应用

  1. 求树上两点之间距离。
  2. 树上差分。

LCA 求树上两点之间距离

维护 dis_xdisx​ 表示根结点到 xx 的距离。

xx 到 yy 的简单路径的长度为 dis_x+dis_y-2\times dis_{\texttt{lca}(x,y)}disx​+disy​−2×dislca(x,y)​。

LCA 例题

first:P5836

方法 1

点权可以转为 00 或 11,维护 dis_idisi​ 表示由根结点到 ii 的距离。

维护深度 dep_idepi​,对于每次询问,若 (dis[a]+dis[b]-2*dis[lcad]+w[lcad]==dep[a]+dep[b]-2*dep[lcad]+1)&&c!='H'dis[a]+dis[b]-2*dis[lcad]+w[lcad]==0&&c=='H' 则输出 00,否则输出 11。

方法 2

若一条边的两个端点的 ww 相同,则 unionn 这两个端点。

若一条路径上点权相同,则两个端点一定在同一集合。若该集合的权值不等于询问,输出 00,否则输出 11。

while(m--)
{
		int x, y;
		char c;
		cin>>x>>y>>c;
		if(c=='H')
		{
			cout<<!(find(x)==find(y)&&w[x]==0);
		}
		else
		{
			cout<<!(find(x)==find(y)&&w[x]==1);
		}
}
方法 3

维护 dp_{i,j}dpi,j​ 表示 ii 向上动 2^j2j 步到达的结点编号,维护 yes_{i,j,0/1}yesi,j,0/1​ 表示 ii 向上跳 2^j2j 步是否有 ww 为 0/10/1 的点。

yes[cur][i][0]=yes[cur][i-1][0]|yes[dp[cur][i-1]][i-1][0],yes[cur][i][1]=yes[cur][i-1][1]|yes[dp[cur][i-1]][i-1][1];

初始状态:dp_{i,0}=fa_idpi,0​=fai​,yes_{i,0,w_{fa}}=1yesi,0,wfa​​=1。

second:CF519E

若 AA 到 BB 的距离为奇数,则答案直接为 00。

否则分情况讨论:

  1. 中间位置的点 x=lcax=lca

    xx 儿子结点中包含 AA 和 BB 的子树剔除,其余为答案。

  2. 中间位置的点 xx 不是 lcalca

    约定深度较大的点为 BB,找到 BB 向上距离 xx 一步的点 pp,则答案为 size_x-size_psizex​−sizep​。

注意特殊情况:A==BA==B 时,答案为 nn。

从 lcalca 到 xx 的距离为 \frac{dep_B-dep_A}{2}2depB​−depA​​。

void work(int x,int y)
{
	if(x==y)
	{
		cout<<n<<"\n";
		return ;
	}
	if(dep[x]==dep[y])
	{
		for(int i=14;i>=0;i--)
		{
			if(dp[x][i]!=dp[y][i])
			{
				x=dp[x][i],y=dp[y][i];
			}
		}
		cout<<size[1]-size[x]-size[y]<<"\n";
		return  ;
	}
	if(dep[x]<dep[y]) swap(x,y);
	if((dep[x]-dep[y])%2==1)
	{
		cout<<"0\n";
		return ;
	}
	int x2=x,len=(dep[x]-dep[y])/2;
	for(int i=14;i>=0;i--)
	{
		if(dep[dp[x][i]]>=dep[y])
		{
			x=dp[x][i];
		}
	}
	if(x==y)
	{
		len+=dep[x];
		for(int i=14;i>=0;i--)
		{
			if(dep[dp[x2][i]]>len)
			{
				x2=dp[x2][i];
			}
		}
		cout<<size[dp[x2][0]]-size[x2]<<"\n";
		return ;
	}
	for(int i=14;i>=0;i--)
	{
		if(dp[x][i]!=dp[y][i])
		{
			x=dp[x][i],y=dp[y][i];
		}
	}
	len+=dep[x]-1;
	for(int i=14;i>=0;i--)
	{
		if(dep[dp[x2][i]]>len)
		{
			x2=dp[x2][i];
		}
	}
	cout<<size[dp[x2][0]]-size[x2]<<"\n";
}

Third:P8972 一切都已过去

题解:P8972 『GROI-R1』 一切都已过去 - 洛谷专栏

方便阅读搬过来。

从数据范围很容易发现,如果我们把边权累乘再判整数,炸掉是必然的,这时候,我们来发现一个性质:只有小数部分有 22 和 55 相乘的时候,才可能变成整数。当然,这并不是绝对的,例如 2.02 \times 52.02×5 就不是整数。从上面举的例子很容易发现一个性质:两个实数的乘积是否为整数与小数点数位也有关系。一对 22 和 55 可以抵消掉一个小数点数位(22 和 55 可以在任意且不同数位上,并且 22 和 55 的倍数也有用)。这时,我们可以将边权通过不断 \times 10×10 变成整数,并分解质因数分别求因数中 22 和 55 的个数(点权也要处理)。22 和 55 的个数求出来了,小数点数位也很好处理。最终的小数点位数应该是所有路径上的边权小数点位数之和,所以我们在将边权化整数时再维护一个变量统计小数点位数并记录到邻接矩阵里。若路径 xx 到 yy 的总边权乘上 xx 的点权得到的结果中 22 的个数和 55 的个数大于或等于总小数点位数,则其为整数。分别维护即可。

注意:若边权或点权为 00 则对应维护的当前点权或点权的 22 和 55 赋予极大值。

Latex有双倍问题,完整版请在安全访问中心 - 洛谷查看

相关推荐
肥猪猪爸1 小时前
使用卡尔曼滤波器估计pybullet中的机器人位置
数据结构·人工智能·python·算法·机器人·卡尔曼滤波·pybullet
readmancynn1 小时前
二分基本实现
数据结构·算法
萝卜兽编程1 小时前
优先级队列
c++·算法
盼海2 小时前
排序算法(四)--快速排序
数据结构·算法·排序算法
一直学习永不止步2 小时前
LeetCode题练习与总结:最长回文串--409
java·数据结构·算法·leetcode·字符串·贪心·哈希表
Rstln2 小时前
【DP】个人练习-Leetcode-2019. The Score of Students Solving Math Expression
算法·leetcode·职场和发展
芜湖_3 小时前
【山大909算法题】2014-T1
算法·c·单链表
珹洺3 小时前
C语言数据结构——详细讲解 双链表
c语言·开发语言·网络·数据结构·c++·算法·leetcode
几窗花鸢3 小时前
力扣面试经典 150(下)
数据结构·c++·算法·leetcode
.Cnn3 小时前
用邻接矩阵实现图的深度优先遍历
c语言·数据结构·算法·深度优先·图论