求解lca问题

最新推荐文章于 2022-02-24 11:29:41 发布
最新推荐文章于 2022-02-24 11:29:41 发布
阅读量114 收藏
点赞数
分类专栏： acm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_ggboy/article/details/107068661
版权

文章目录

倍增法

一篇博客
最常用，也是最简单的算法，实质就是直接对暴力使用倍增优化将复杂度降低达到需求。
d e p t h [ ] depth[] depth[]为每个节点的深度， f a [ i ] [ j ] fa[i][j] fa[i][j],i节点的 2 j 2^j 2j的父亲。 l g [ i ] = l o g 2 i + 1 lg[i]=log_2{i}+1 lg[i]=log2​i+1

const int maxn=5000001;
int depth[maxn],fa[maxn][22],lg[maxn];
vector<int >g[maxn];
void dfs(int now,int fath)//dfs初始化fa和depth，传入参数为根节点
{
	fa[now][0]=fath;
	depth[now]=depth[fath]+1;
	for(int i=1;i<=lg[depth[now]];++i)
	{
		fa[now][i]=fa[fa[now][i-1]][i-1];//递推更新fa
	}
	for(int i=0;i<g[now].size();i++)//寻找子节点
	{
		if(g[now][i]!=fath)
		dfs(g[now][i],now);
	}
}
int lca(int x,int y)
{
	if(depth[x]<depth[y])//使x的深度大于y的深度
	{
		swap(x,y);
	}
	while(depth[x]>depth[y])
	{
		x=fa[x][lg[depth[x]-depth[y]]-1];//使两者深度相同
	}
	if(x==y)
	return x;
	for(int k=lg[depth[x]]-1;k>=0;--k)//树上倍增
	{
		if(fa[x][k]!=fa[y][k])
		{
			x=fa[x][k],y=fa[y][k];
		}
	}
	return fa[x][0];
}
main(void)
{
	int n,m,s;
	cin>>n>>m>>s;
	for(int i=1;i<n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		g[x].push_back(y);
		g[y].push_back(x); 
	}
	for(int i=1;i<=n;i++)
	{
		lg[i]=lg[i-1]+(1<<lg[i-1]==i);
	}
	dfs(s,0);
	for(int i=1;i<=m;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		printf("%d\n",lca(x,y));	
	}
	return 0;
}

题目

二叉树问题
统计树的深度、宽度、两个点之间的上行边数和下行边数

const int maxn=5000001;
int depth[maxn],fa[maxn][22],lg[maxn];
vector<int >g[maxn];
int ans1=0;
int ans2[20000]={0};
int ans22=0;
void dfs(int now,int fath)
{
	fa[now][0]=fath;
	depth[now]=depth[fath]+1;
	ans1=max(ans1,depth[now]);
	ans2[depth[now]]++;
	ans22=max(ans22,ans2[depth[now]]);
	for(int i=1;i<=lg[depth[now]];++i)
	{
		fa[now][i]=fa[fa[now][i-1]][i-1];
	}
	for(int i=0;i<g[now].size();i++)
	{
		if(g[now][i]!=fath)
		dfs(g[now][i],now);
	}
}
int lca(int x,int y)
{
	
	int ans=0;
	int ans11=0;
	int flag=0;
	if(depth[x]<depth[y])
	{
		swap(x,y);
		flag=1;
	}
	while(depth[x]>depth[y])
	{
		ans11+=1<<(lg[depth[x]-depth[y]]-1);
		x=fa[x][lg[depth[x]-depth[y]]-1];
	}
	if(x==y)
	{
		if(flag)
		return ans11;
		return 2*ans11;
	}
	for(int k=lg[depth[x]]-1;k>=0;--k)
	{
		if(fa[x][k]!=fa[y][k])
		{
			x=fa[x][k],y=fa[y][k];
			ans+=1<<k;
			ans11+=1<<k;
		}
	}
	if(flag)
	return (ans+1)*2+(ans11+1);
	return (ans+1)+(ans11+1)*2;
}
main(void)
{
	int n,m,s=1,u,v;
	cin>>n;
	for(int i=1;i<n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		g[x].push_back(y);
		g[y].push_back(x); 
	}
	for(int i=1;i<=n;i++)
	{
		lg[i]=lg[i-1]+(1<<lg[i-1]==i);
	}
	dfs(s,0);
	cin>>u>>v;
	printf("%d\n%d\n%d\n",ans1,ans22,lca(u,v));
	return 0;
}

P2420 让我们异或吧
运用lca中的dfs，求得所有点到根的异或

const int maxn=5000001;
int depth[maxn],fa[maxn][22],lg[maxn];
vector<int >g[maxn];
int ans1=0;
int ans2[20000]={0};
int ans22=0;
void dfs(int now,int fath)
{
	fa[now][0]=fath;
	depth[now]=depth[fath]+1;
	ans1=max(ans1,depth[now]);
	ans2[depth[now]]++;
	ans22=max(ans22,ans2[depth[now]]);
	for(int i=1;i<=lg[depth[now]];++i)
	{
		fa[now][i]=fa[fa[now][i-1]][i-1];
	}
	for(int i=0;i<g[now].size();i++)
	{
		if(g[now][i]!=fath)
		dfs(g[now][i],now);
	}
}
int lca(int x,int y)
{
	
	int ans=0;
	int ans11=0;
	int flag=0;
	if(depth[x]<depth[y])
	{
		swap(x,y);
		flag=1;
	}
	while(depth[x]>depth[y])
	{
		ans11+=1<<(lg[depth[x]-depth[y]]-1);
		x=fa[x][lg[depth[x]-depth[y]]-1];
	}
	if(x==y)
	{
		if(flag)
		return ans11;
		return 2*ans11;
	}
	for(int k=lg[depth[x]]-1;k>=0;--k)
	{
		if(fa[x][k]!=fa[y][k])
		{
			x=fa[x][k],y=fa[y][k];
			ans+=1<<k;
			ans11+=1<<k;
		}
	}
	if(flag)
	return (ans+1)*2+(ans11+1);
	return (ans+1)+(ans11+1)*2;
}
main(void)
{
	int n,m,s=1,u,v;
	cin>>n;
	for(int i=1;i<n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		g[x].push_back(y);
		g[y].push_back(x); 
	}
	for(int i=1;i<=n;i++)
	{
		lg[i]=lg[i-1]+(1<<lg[i-1]==i);
	}
	dfs(s,0);
	cin>>u>>v;
	printf("%d\n%d\n%d\n",ans1,ans22,lca(u,v));
	return 0;
}

疫情控制
要求分配军队，运用了lca的dfs，得到每个点的祖先节点情况。

const int N=5e4+3;
ll sum,dis[N],dist[N];
int n,m,u,cnt,cont;
int am[N],lg[N],f[N][17],dp[N],vis[N],fre[N],b[N],pl[N],nee[N];
int tt,head[N],to[N<<1],nex[N<<1],w[N<<1];
vector<int>arv[N];
struct LCA{//直接套的lca模板
	void pre(int g,int F){//预处理父亲;
		for(int i=head[g],v;i;i=nex[i]){
			v=to[i];
			if(v==F)continue;
			f[v][0]=g,dp[v]=dp[g]+1,dis[v]=dis[g]+(ll)w[i];
			for(int j=1;j<=lg[dp[v]];++j)
				f[v][j]=f[f[v][j-1]][j-1];
			pre(v,g);
		}
		return ;
	}
	int get(int x,int y){
		if(dp[x]>dp[y])swap(x,y);
		for(int i=lg[dp[y]-dp[x]];i>=0;--i)
			if(dp[f[y][i]]>=dp[x])y=f[y][i];
		if(x==y)return x;
		for(int i=lg[dp[x]];i>=0;--i)
			if(f[x][i]!=f[y][i])x=f[x][i],y=f[y][i];
		return f[x][0];
	}
}lca;
inline void add(int x,int y,int W){
	to[++tt]=y,nex[tt]=head[x],w[tt]=W,head[x]=tt;
	return ;
}
inline bool dfs(int g,int F){
	if(vis[g]&&!pl[g])return true;//若当前节点不是根节点的子节点,且有标记,说明当前子树已全部被标记;
	bool flag=0;
	for(int i=head[g],v;i;i=nex[i]){
		v=to[i];
		if(v==F)continue;
		if(!dfs(v,g))return false;//有一个叶子节点未被标记就需要加入need集合;
		flag=1;
	}
	return flag;
}
inline bool check(ll mid){
	for(int i=1;i<=cnt;++i)arv[i].clear();
	memset(vis,0,sizeof vis);
	for(int i=1;i<=m;++i){
		int y=am[i];
		dist[i]=0;
		for(int j=dp[y];j>=0;--j)//;将其向父亲跳
			if(f[y][j]>1&&dist[i]+dis[y]-dis[f[y][j]]<=mid){
				dist[i]+=dis[y]-dis[f[y][j]];
				y=f[y][j];
			}
		vis[y]=1;//将当前节点标记;
		int j=pl[y];//找到对应的根节点的子节点的编号;
		if(j){
			arv[j].push_back(mid-dist[i]);//将剩余距离加入第j个子节点;
			if(arv[j].size()>1&&arv[j][arv[j].size()-2]<arv[j][arv[j].size()-1])
				swap(arv[j][arv[j].size()-2],arv[j][arv[j].size()-1]);//将剩余距离最短的点放到尾部;
		}
	}
	int cnt1=0,cnt2=0;
	for(int i=1;i<=cnt;++i){
		if(!dfs(to[b[i]],1)){//判定是否需要军队驻扎;
			if(arv[i].size()&&arv[i][arv[i].size()-1]<w[b[i]]*2)
				arv[i].pop_back();//若当前点存在无法先到达根节点,再返回当前点的的军队,就将其军队用来驻扎当前点;
			else nee[++cnt1]=w[b[i]];//否则将当前点加入need集合;
		}
		for(int j=0;j<arv[i].size();++j)
			if(arv[i][j]>=w[b[i]])
				fre[++cnt2]=arv[i][j]-w[b[i]];//将符合条件的军队加入free集合;
	}
	if(cnt1>cnt2)return false;//如果军队数小于节点数,就无法完全覆盖;
	sort(nee+1,nee+1+cnt1);
	sort(fre+1,fre+1+cnt2);//排序;
	while(cnt1){//反向比较;
		if(fre[cnt2]<nee[cnt1])return false;//若当前点无法被当前军队覆盖,那么在他之后的军队也无法将其覆盖;
		--cnt2,--cnt1;
	}
	return true;//将节点完全覆盖;
}
inline ll solve(){
	ll l=0,r=sum+1;
	while(l<r){
		ll mid=l+r>>1;
		if(check(mid))r=mid;
		else l=mid+1;
	}
	return l;
}
int main(){
	cin>>n;
	lg[0]=-1;
	for(int i=1;i<=n;++i)lg[i]=lg[i>>1]+1;//初始化lg数组;
	int x,y,W;
	for(int i=1;i<n;++i)cin>>x>>y>>W,add(x,y,W),add(y,x,W),sum+=W;
	for(int i=head[1],v;i;i=nex[i])v=to[i],b[++cnt]=i,pl[v]=cnt;//b记录根节点的第cnt条边,pl记录节点对应第几条边;
	cin>>m;
	lca.pre(1,0);
	for(int i=1;i<=m;++i)cin>>x,am[i]=x;
	if(m<cnt)puts("-1");//若军队数小于根节点的子节点数,则一定无法完全覆盖;
	else cout<<solve()<<'\n';//否则一定可以完全覆盖;
	return 0;
}
csdn_ggboy
关注
专栏目录
二叉树的公共祖先(LCA问题)
元宝的博客
02-21 399
二叉树的公共祖先 二叉树的公共祖先—力扣链接 问题内容:给定一个二叉树, 找到该树中两个指定节点的最近公共祖先 输入输出示例： 1.代码实现 思路分析： 如果其中一个是树的根，那么它一定就是公共祖先； 接下来无法就是三种情况：全在左子树；全在右子树；一个在左子树，一个在右子树； /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; *
ACM: 最近公共祖先问题LCA 图论题 …
smile_benson
05-19 311
Closest Common Ancestors Description Write a program that takes as input a rooted tree and a list of pairs of vertices. For each pair (u,v) the program determines the closest common ancestor of u and
【leetcode】二叉树的LCA问题：Lowest Common Ancestor of a Binary Tree
pangzhe_sd的博客
07-14 893
还是递归问题，定义left和right递归调用原函数，直到叶子结点为止。 判断两个输入参数的父节点，有三种情况： 第一，分别为左右树，父节点为root (第一个if条件) 第二，遍历到P和Q时，将其返回给left和right,(第二个if条件) 第三，根据left和right的值进行判断，父节点是左边还是右边并返回对应值（第三个if条件）。 /**  * Definition for
ACM——LCA
weixin_40446193的博客
05-10 400
一、算法定义 LCA是在线查询树上两点的最近公共祖先的算法，可运用倍增的方法，时间复杂组O（nlogn） 二、算法过程 1.倍增使深度较深的点跳到和深度较浅的点同一深度。 2.两个点一起往上跳，直到找到公共祖先 三、模板 //预处理：通过dfs，求出树上每个节点的深度。注：p[x][0]是x的父节点，如果遍历到父节点则跳过，其他的与该点相邻的点都是他的子节点 void dfs(int x) { ...
LCA问题
m0_56039061的博客
02-24 288
介绍Tarjan算法求LCA问题。
求二叉树:二叉树最近公共祖先(LCA)问题 和 /节点最大距离问题.
GreyBtfly的博客
02-21 600
一.最近公共祖先(LCA) 假设我们有指向所求两点的指针A和B 1.二叉树有指向父亲节点的指针 struct node { ... struct node l,r,prv; //left child,right child,father } 如果我们有每个节点的深度信息的话:  假设deep(A) &gt; deep(B)  ,且deep(A)-deep(B) = s...
算法合集之RMQ与LCA问题PPT学习教案.pptx
10-05
Tarjan算法则主要用于求解LCA问题，其时间复杂度为O(Na(N) + Q)，其中a(N)是O(logN)阶的阿克曼函数，Q表示查询次数，空间复杂度为O(N)。对于±1RMQ问题，存在特定的算法，其预处理和查询时间复杂度均为O(N)。 RMQ和...
RMQ与LCA问题详解：从提出到解决
Tarjan算法专门用于求解LCA问题，其时间复杂度为O(Nα(N)+Q)，其中α(N)是逆 Ackermann 函数，通常增长极慢，空间复杂度为O(N)。而对于±1RMQ问题，存在一种能在预处理O(N)时间内完成，并在每次查询时达到O(1)时间...
3.郭华阳《RMQ与LCA问题》1
08-03
一方面，我们可以将 RMQ 问题转化为等规模的 LCA 问题，通过将数组看作一棵完全二叉树，其中数组元素作为叶子节点，然后构建对应的树结构，从而利用 LCA 算法求解 RMQ。另一方面，也可以将 LCA 问题转化为 RMQ 问题...
LCA问题解法
Hsuxu的专栏
07-10 1134
11-0412       算法之LCA与RMQ问题       Category: 数据结构与算法    View: 11,480 阅    Author: Dong                作者:Dong | 新浪微博：西成懂<span class="separator"> | 可以转载, 但必须以超链接形
LCA问题归约成RMQ求解
01-09
在计算机科学领域，特别是数据结构和算法分析中，"LCA问题归约成RMQ求解"是一个重要的主题。LCA代表最远公共祖先（Least Common Ancestor），而RMQ代表范围最小值查询（Range Minimum Query）。这两个概念常用于树形...
lca问题
h_666666的博客
06-22 375
leetcode有一个简单版的lca 但是这个我不是很理解，，，root指的是已经知道了根节点？ 题目链接 https://leetcode-cn.com/problems/0owest-common-ancestor-of-a-binary-tree/ 代码： /** * Definition for a binary tree node. * public class TreeNode {...
经典ACM图论问题讲解
06-05
这是关于ACM图论问题的经典讲解，简洁精辟的讲解了常见的ACM图论问题！
VCS使用问题记录
Darever专栏
05-11 1万+
本文作为vcs学习记录，不定期更新； Q1: 使用vlogan deepfifo_pkg.sv -ntb_opts uvm Error-[SV-LCM-PND] Package not defined test/deepfifo_pkg.sv, 2 deepfifo_pkg, "uvm_pkg::" Package scope resolution failed. Token 'uvm_pkg' is not a package. Originating module 'deepfifo_...
郭华阳《RMQ与LCA问题》
08-10
其中，LCA using RMQ是一种利用RMQ技术来求解LCA问题的方法，通过预先计算节点到根的路径上的所有节点权值（如深度），然后使用RMQ数据结构来快速找到两节点的最近公共祖先。 郭华阳的论文可能详细阐述了这两种问题...
VCS仿真与调试
热门推荐
Holden_Liu的博客
02-09 3万+
-cc指定C编译器，默认使用
VCS常用开关选项解释
yh13572438258的博客
12-02 1481
VCS的仿真选项分编译（compile-time）选项和运行（run-time）选项。 1.1VCS常用的编译选项 表 21VCS常用的编译选项 选项 说明 -assertdumpoff| enable_diag| filter_past 定义SystemVerilog断言（SVA） dumpoff：禁止将SVA信息DUMP到VPD中 enable_diag：使能SVA结果报告由运行选项进一步控制 ...
LCA问题的三种求法
HJ
08-16 923
先来看一道例题： hdu 2586 How far away ？ http://acm.hdu.edu.cn/showproblem.php?pid=2586 题目描述的就是给你一棵n个节点的树，然后Q次询问，每次询问的内容是节点x和节点y的最近公共祖先（LCA） 接下来就来说一说LCA（最近公共祖先） 你需要准备的预备知识： ①ST表处理RMQ问题； ②并查集的思想以及实现； ③...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值