POJ 1330 Nearest Common Ancestors（求LCA的三种方法）

最新推荐文章于 2021-10-04 18:59:33 发布
最新推荐文章于 2021-10-04 18:59:33 发布
阅读量2k 收藏 5
点赞数
分类专栏： 图 文章标签： struct 算法 table null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shiqi_614/article/details/7841592
版权

1.离线Tarjan

       设我们求点对(u,v)的最近公共祖先。

       利用在DFS过程中，从点u第一次到点v的过程中，必定是从u开始，经过u和v的最近公共祖先的S，然后到达v的，这时候u和v都是在S为根结点的子树里的。

       如果我们在访问v的时候，u已经被访问过了，这时候，如果我们知道u在以哪个结点S为根结点的子树里，我们就知道它们的公共祖先了，即S。借助并查集，在DFS过程中，我们每到达一个节点x，便创建一棵以x为根结点的子树（即在并查集中令fa[x]=x），将不断将它的子结点连同子结点的子结点……合并到这棵子树下（即借助并查集的并操作令fa[son of x]=x），注意必须在子结点结束DFS过程后才合并，因为我们查询的点对(u,v)也有可能在以结点sone of x为根的子树下。则我们访问到u或者v的时候，判断v或者u是否已经被访问过，如果被访问过，那么v或者u所在的子树的根结点S即是它们的公共祖先，查找v或u所在子树的根节点借助并查集的查操作（即可即find_fa(v或者u)）。

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
const int N=10005;
int q1,q2,res,fa[N],deg[N];
int find_fa(int u)
{
	if(fa[u]==u) return u;
	return fa[u]=find_fa(fa[u]);
}
struct Edge
{
	int to;
	Edge *next;
}memo[N*2],*cur,*adj[N];
void addEdge(Edge *head[],int u,int v)
{
	cur->to=v;
	cur->next=head[u];
	head[u]=cur++;
}
void tarjan(int u)
{
	fa[u]=u;
	for(Edge *it=adj[u];it;it=it->next)
	{
		int to=it->to;
		tarjan(to);
		fa[to]=u;
	}
	if(u==q1||u==q2)
	{
		if(u!=q1) swap(q1,q2);
		if(fa[q2]) res=find_fa(fa[q2]);
	}
}
void init(int n)
{
	for(int i=0;i<=n;i++)
	{
		adj[i]=NULL;
		deg[i]=0;fa[i]=0;
	}
	cur=memo;
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n,u,v;
		scanf("%d",&n);
		init(n);
		for(int i=0;i<n-1;i++)
		{
			scanf("%d%d",&u,&v);
			addEdge(adj,u,v);	deg[v]++;
		}

		scanf("%d%d",&q1,&q2);
		for(int i=1;i<=n;i++) if(deg[i]==0) {tarjan(i);break;}
		printf("%d\n",res);
	}
	return 0;
}

2.倍增法

       倍增法先利用一次dfs处理出每个结点的深度及其每个结点i的2^j层的祖先是谁——也可以表述成从结点i向上跳2*j层（即dp[i][j]）。

       对于询问u，v的公共祖先，假设u的深度比v小，先将u跳到与v同一层的某个u的祖先u1，这时候，如果u1与v是同一个点，那么它们的公共祖先就是这u1，即也是v。

       否则，这时候，我们就要在树上向上跳若干层，使得u和v第一次交汇，也即得到u的某个祖先u2和v的某个祖先v2，满足u2=v2，那么那个交汇的点就是它们的最近公共祖先。如果我们跳到这个交汇点的下一层的结点，设为u3和v3，即满足dp[u3][0]=u2。注意到，从从u跳到u3的过程中，始终满足dp[u’][i]!=dp[v’][i]。

       设u到u3的层数为x，那么这个x是可以表达成一个二进制数的，即x=2^k1+2^k2+..，即我们要从u达到u3要跳2^k1，2^k2…层——不就是我们处理出来的dp函数？那么，我们寻找满足dp[u’][k]!=dp[v’][k]的最大k值，然后跳到那一层（即令u’’=dp[u’][k]，v’’=dp[v’][k]），然后再寻找满足dp[u’’][k]!=dp[v’’][k]的最大k值，再跳到那一层。。。这样到最后我们就到了u3层。如果还不理解可以画个图帮助理解下。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N=10005;
const int Log=20;
int dp[N][Log],depth[N],deg[N];
struct Edge
{
	int to;
	Edge *next;
}memo[N*2],*cur,*head[N];
void addEdge(int u,int v)
{
	cur->to=v;
	cur->next=head[u];
	head[u]=cur++;
}
void dfs(int u)
{
	depth[u]=depth[dp[u][0]]+1;
	for(int i=1;i<Log;i++) dp[u][i]=dp[dp[u][i-1]][i-1];
	for(Edge *it=head[u];it;it=it->next)
	{
		dfs(it->to);
	}
}
int lca(int u,int v)
{
	if(depth[u]<depth[v]) swap(u,v);
	for(int st=1<<(Log-1),i=Log-1;i>=0;i--,st>>=1)
	{
		if(st<=depth[u]-depth[v])
		{
			u=dp[u][i];
		}
	}
	if(u==v) return u;

	for(int i=Log-1;i>=0;i--)
	{
		if(dp[v][i]!=dp[u][i])
		{
			v=dp[v][i];
			u=dp[u][i];
		}
	}
	return dp[u][0];
}
void init(int n)
{
	for(int i=0;i<=n;i++)
	{
		dp[i][0]=0;
		head[i]=NULL;
		deg[i]=0;
	}
	cur=memo;
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n,u,v;

		scanf("%d",&n);
		init(n);
		for(int i=0;i<n-1;i++) 
		{
			scanf("%d%d",&u,&v);
			addEdge(u,v);
			deg[v]++;
			dp[v][0]=u;
		}
		for(int i=1;i<=n;i++) if(deg[i]==0) {dfs(i);break;}

		scanf("%d%d",&u,&v);
		printf("%d\n",lca(u,v));
	}
	return 0;
}

3. 转化成RMQ

       RMQ：区间最小值询问问题。

       RMQ（A，i，j）：对于线性序列A中，询问区间[i，j]上的最小值。

       ST(Sparse Table)算法是一个非常有名的在线处理RMQ问题的算法，它可以在O(logN)时间内进行预处理，然后在O(1)的时候内回答每个查询。

      首先是预处理，用动态规划DP解决。设A[i]是要求区间最值的数列，dp[i,j]表示从第i个数起连续2^j个数中的最大值。例如数列3 2 4 5 6 8 1 2 9 7，dp[1,0]表示从第1个数起，长度为2^0=1的最大值，其实就是3这个数。dp[1,2]=5，dp[1,3]=8，dp[2,0]=2，dp[2,1]=4……从这里可以看出dp[i,0]其实就等于A[i]。这样，DP的状态，初值都已经有了，剩下的就是状态转移方程。我们把dp[i,j]平均分成两段（因为dp[i,j]一定是偶数个数字），从i+2^(j-1)-1为一段，从i+2^(j-1)到i+2^j-1为一段（长度都为2^(j-1)）。用上例说明，当i=1，j=3时就是3 2 4 5 和 6 8 1 2 这两段。F[i,j]就是这两段的最大值中的最大值。于是我们得到了动态规划方程dp[i,j]=max(dp[i,j-1],dp[i+2^(j-1),2^(j-1)。

       然后是查询。取k=[log2(j-i+1)]，则有：RMQ(A,i,j)=min(dp[i,k],dp[j-2^k+1,k])。举例说明，要求区间[2，8]的最大值，就要把它分成[2，5]和[5，8]两个区间，因为这两个区间的最大值我们可以直接由dp[2,2]和dp[5,2]得到。

       对有根树T进行DFS，将遍历到的结点按照顺序记下，我们将得到一个长度为2N – 1的序列，称之为T的欧拉序列F。

       每个结点都在欧拉序列中出现，我们记录结点u在欧拉序列中第一次出现的位置为pos(u)。

       下图是一个例子：

       根据DFS的性质，对于两结点u、v，从pos(u)遍历到pos(v)的过程中经过LCA(u,v)有且仅有一次，且深度是深度序列B[pos(u)…pos(v)]中最小的。

       即LCA(T, u, v) =RMQ(B, pos(u), pos(v))

       有两种写法。

       第一 种：在rmq_depth里记录在如上图所示的深度序列，在rmq_hash里记录每个深度序列里每个位置对应的点，dp[i][j]表示从i开始的长度为2^j的序列中深度最小的值的位置。比如查询(u,v)的最近公共祖先，即是rmq_hash[min(dp[u][k],dp[v-(1<<k)+1][k])];

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
const int N=10005;
const int Log=30;
int deg[N],dp[N*2][Log];
int dfn;//dfs过程中用到的时间戳
int rmq_pos[N];//表示节点u第一次出现的位置
int rmq_depth[N*2];//表示路径上的每个点的深度
int rmq_hash[N*2];//表示路径上的每个深度代表的点
struct Edge
{
	int to;
	Edge *next;
}memo[N*2],*cur,*adj[N];
void addEdge(Edge *head[],int u,int v)
{
	cur->to=v;
	cur->next=head[u];
	head[u]=cur++;
}
void dfs(int u,int d)
{
	rmq_pos[u]=dfn;
	rmq_depth[dfn]=d;
	rmq_hash[dfn++]=u;
	for(Edge *it=adj[u];it;it=it->next)
	{
		int v=it->to;
		dfs(v,d+1);
		rmq_depth[dfn]=d;
		rmq_hash[dfn++]=u;
	}
}
void solve(int n)
{
	for(int i=1;i<=n;i++) dp[i][0]=i;
	for(int j=1;(1<<j)<=n;j++) 
		for(int i=1;i+(1<<j)-1<=n;i++)
		{
			int tmp1=i,tmp2=i+(1<<(j-1));
			if(rmq_depth[dp[tmp1][j-1]]<rmq_depth[dp[tmp2][j-1]])
				dp[i][j]=dp[tmp1][j-1];
			else dp[i][j]=dp[tmp2][j-1];
		}
}
int rmq(int u,int v)
{
	u=rmq_pos[u],v=rmq_pos[v];
	if(u>v) swap(u,v);
	int k=(int)(log(v*1.0-u+1)/log(2.0));
	int tmp1=u,tmp2=v-(1<<k)+1;
	return rmq_hash[min(dp[tmp1][k],dp[tmp2][k])];
}
void init(int n)
{
	dfn=1;
	for(int i=0;i<=n;i++)
	{
		adj[i]=NULL;
		deg[i]=0;
	}
	cur=memo;
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n,u,v;
		scanf("%d",&n);
		init(n);
		for(int i=0;i<n-1;i++)
		{
			scanf("%d%d",&u,&v);
			addEdge(adj,u,v);	deg[v]++;
		}
		for(int i=1;i<=n;i++) if(deg[i]==0){dfs(i,0);break;}
		solve(2*n-1);
		scanf("%d%d",&u,&v);
		printf("%d\n",rmq(u,v));
	}
	return 0;
}
       第二种：对第一种写法做了些改进，即如果在一棵子树下，深度值较大的同时编号也较大，那么在对dp数组进行处理时就可以不用借助上面的rmq_depth了。 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
const int N=10005;
const int Log=30;
int deg[N],dp[N*2][Log];
int dfn;
int rmq_low[N*2];
int rmq_pos[N*2];
int rmq_hash[N*2];
struct Edge
{
	int to;
	Edge *next;
}memo[N*2],*cur,*adj[N];
void addEdge(Edge *head[],int u,int v)
{
	cur->to=v;
	cur->next=head[u];
	head[u]=cur++;
}
void dfs(int u)
{
	int tmp=dfn;
	rmq_low[dfn]=dfn;
	rmq_pos[u]=dfn;
	rmq_hash[dfn++]=u;
	for(Edge *it=adj[u];it;it=it->next)
	{
		int v=it->to;
		dfs(v);
		rmq_low[dfn]=tmp;
		rmq_hash[dfn++]=u;
	}
}
void solve(int n)
{
	for(int i=1;i<=n;i++) dp[i][0]=rmq_low[i];
	for(int j=1;(1<<j)<=n;j++)
		for(int i=1;i+(1<<j)-1<=n;i++)
			dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
}
int rmq(int u,int v)
{
	u=rmq_pos[u],v=rmq_pos[v];
	if(u>v) swap(u,v);
	int k=(int)(log(v*1.0-u+1)/log(2.0));
	int tmp1=u,tmp2=v-(1<<k)+1;
	return rmq_hash[min(dp[tmp1][k],dp[tmp2][k])];
}
void init(int n)
{
	dfn=1;
	for(int i=0;i<=n;i++)
	{
		deg[i]=0;
		adj[i]=NULL;
	}
	cur=memo;
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n,u,v;
		scanf("%d",&n);
		init(n);
		for(int i=0;i<n-1;i++)
		{
			scanf("%d%d",&u,&v);
			addEdge(adj,u,v);	deg[v]++;
		}
		for(int i=1;i<=n;i++) if(deg[i]==0){dfs(i);break;}
		solve(2*n-1);
		scanf("%d%d",&u,&v);
		printf("%d\n",rmq(u,v));
	}
	return 0;
}


shiqi_614
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Nearest Common Ancestors (LCA)
qq_44641782的博客
02-01 288
数据结构中的树，在计算机科学中是非常重要的，例如我们来看看下面这棵树： 在图中我们对每个节点都有编号了。 8号节点是这棵树的根。我们定义，一个子节点向它的根节点的路径上，任意一个节点都称为它的祖先。例如， 4号节点是16号节点的祖先。而10号节点同样也是16号的祖先。事实上，16号的祖先有8，4，10，16共四个。另外8， 4， 6，7都是7号节点的祖先，所以7号和16号的公共祖先是4和8号，而...
图的强连通分量，块，割点，桥
热门推荐
08-06 1万+
写在前面：整合和参考了网上的一些相关文章和刘汝付佳的《内功心法》里的部分内部。       因为在求强连通分量，块，割点，桥的时候，其基本过程是DFS，所以对DFS的一基本的知识作些介绍。       为了叙述方便，规定DFS过程将给结点着色：白色为没有考虑过的点，黑色为已经完全考虑过的点，灰色为发现过但没有处理过的点。灰色点组成了遍历边界。 DFS遍历       DFS遍历优先扩展新发
POJ 1001 Exponentiation 求高精度幂 C源代码
11-17
如题所示，亲测可用。求高精度幂，不会的同学可以参考下，会做的同学可以给挑挑毛病！大家以代码会友！
【POJ1330】最近公共祖先（LCA）：并查集+深搜 - cxllyg的专栏 - 博客频道 - CSDN.NET1
08-03
2. bool nodePath (bstNode* pRoot, int value, std::vector<bstNode*>& path) 3. { 6
poj1330( 树的先跟遍历）
u014236804的专栏
08-03 482
#include #include #include #include #include using namespace std; const int N=10010; vector a[N]; int f[N],r[N]; void DFS(int u,int dep) { r[u]=dep; for(vector::iterator it=a[u].begin()
算法详解（LCA&RMQ&tarjan）补坑啦！完结撒花(｡◕ˇ∀ˇ◕)
weixin_30346033的博客
05-10 86
首先，众所周知，求LCA共有3种算法（树剖就不说了，太高级，以后再学。。）。 1、树上倍增（ST表优化） 2、RMQ&时间戳（ST表优化） 3、tarjan（离线算法）不讲。。(后面补坑啦！) 一、树上倍增 这种方法原理是这样的： 我们可以知道，最朴素的算法就是一步一步的并查集往上找，知道找到2个点并查集相同，即为LCA 但这种算法的时间效率为O（NM）看到0<n,m&...
倍增&RMQ&LCA
zjh_2017的博客
11-06 386
昨天晚上的事情就不提了，不要在意这些细节，我今天下午800m明天上午1500m给她跑个成绩出来。mad 今天上午，本来我是真的很想很想很想去看比赛的，我小学4年、初中2年的运动会从来不缺我给同学喊加油。要不是昨天晚上那一出戏，我现在就在安安心心看比赛。mad 我就是很看重运动会，运动会我从来都是很浪的，再说我不是停课了吗，结果事情闹得这么大，我一年就浪这么一次好吧？？mad 好吧，那就安心待在
Nearest Common Ancestors
dianan0938的博客
01-16 125
Nearest Common Ancestors 　　　　题目大意：给你k组数据，每组数据输入一个树和一组询问，询问树上LCA。 　　　　注释：n<=10000。 　　　　　　想法：咳咳，我初学LCA，先来一道裸题压压惊。LCA？(Least Common Ancestors)，是指最近公共祖先。最近公共祖先？是指他们的祖先中距离它们最近者。我们在此介绍一种方法：朴素法。记录...
Nearest Common Ancestors POJ-1330
TGX的博客
10-04 228
A rooted tree is a well-known data structure in computer science and engineering. An example is shown below: In the figure, each node is labeled with an integer from {1, 2,…,16}. Node 8 is the root of the tree. Node x is an ancestor of node y if node x is
POJ1330(倍增LCA解法)
weixin_43843730的博客
11-06 626
传送门 题意：给你一颗树，让你找出两点的最近公共祖先。 题解：LCA模板题，这里我使用倍增的方法解决 我使用倍增来在线求 LCA ，时间和空间复杂度分别是 O((n+q)logn) 和 O(nlogn) 。q是查询次数。 算法基本思想： 　　　　①如果 a 和 b 深度不同，先把深度调浅，使他变得和浅的那个一样 　　　　②现在已经保证了 a 和 b 的深度一样，所以我们只要把两个一起一步一步往上移...
POJ.rar_poj java_poj1048
09-24
POJ1048，加强版的约瑟夫问题 难度中等
LCA的tarjan算法
08-07
对于LCA问题，有不少解法，这儿提供了tarjan算法，这是一种离线算法，读入所有输入然后一并处理，并且利用并查集的思想，从根节点开始DFS，对每一个DFS的节点，先把他的父亲节点指向本身，没访问完一个子节点，然后...
poj.rar_poj
09-20
POJ 上的近100道水题，基本涵盖了所有基本算法和数据结构，全部AC
网络流最大流的sap()算法
09-15 8214
现在想将一些物资从S运抵T，必须经过一些中转站。连接中转站的是公路，每条公路都有最大运载量。          每条弧代表一条公路，弧上的数表示该公路的最大运载量。最多能将多少货物从S运抵T？                   这是一个典型的网络流模型。为了解答此题，我们先了解网编流的有关定义和概论。          若有向图G=(V,E)满足下列条件：        1.
hdu 4114 Disney's FastPass
09-06 3432
题意：游戏园里有N个区域，有M条边连接这N个区域，有K个要访问的景点。对于每个景点告诉你这个景点所在的区域，要访问这个景点需要等待一定时间，如果没有FastPass，等待时间有Ti，否则等待时间为FTi，接下来的Ni，表示有Ni个区域可以得到这个景点的FastPass，问从区域1出发，再回到区域1所需要的最少时间。 状态压缩，dis[i][s1][s2]，表示当前走到这个点，s1表示拿到了哪些景
Codeforces Beta Round #11 D. A Simple Task
09-07 2869
题意：有N（最多19个）个点，M条边，问有多少个简单环。 状态压缩，dp[st][i]，终点是i，st表示这个环走过哪几个，定义起点为这些走过的点里最小的。 #pragma comment(linker, "/STACK:102400000,102400000") #include #include #include #include #include #include #incl
hdu 2242 考研路茫茫――空调教室（Tarjan+树型DP）
10-24 2823
题意：给你N个点，M条无向边，并且每个点有一个权值，问把哪条边去掉，能使图分成两个部分，并且这两个部分的权值差最小。 跑一次Tarjan转化成一棵树，然后跑一次树型DP（特别注意重边的处理）。 #include #include #include #include using namespace std; const int N=10005; struct Edge { i
Codeforces Beta Round #27 D. Ring Road 2
09-17 2734
题意：有一个环，现给你一些区间的起点与终点，区间可以在环内，可以在环外，但是在环内环外的区间都不能彼此相交，问可能否，如果可能，输出方案。 2-SAT。 #include #include #include #include #include #include #include #include #include using namespace std; typedef
简述poj3525凸多边形求最大内切圆二分法的解题思路
最新发布
03-13
POJ3525 是一个凸多边形求最大内切圆的问题，可以使用二分法来解决。具体思路是：首先确定一个半径范围，然后在这个范围内进行二分查找，每次取中间值作为半径，判断这个半径是否能够放置在凸多边形内部，如果可以，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值