最近公共祖先LCA(Tarjan(离线)算法)amp;amp; poj1330 amp;amp; hdu2586

2023-12-26 02:38

本文主要是介绍最近公共祖先LCA(Tarjan(离线)算法)amp;amp; poj1330 amp;amp; hdu2586,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

注:这篇文章关于算法解释部分参考☞:http://www.cnblogs.com/JVxie/p/4854719.html

这位大佬写的特别详细,然后我在这个的基础上又增加了两道例题,更方便大家理解

首先是最近公共祖先的概念(什么是最近公共祖先?):

    在一棵没有环的树上,每个节点肯定有其父亲节点和祖先节点,而最近公共祖先,就是两个节点在这棵树上深度最大公共祖先节点

    换句话说,就是两个点在这棵树上距离最近的公共祖先节点

    所以LCA主要是用来处理当两个点仅有唯一一条确定的最短路径时的路径。

    有人可能会问:那他本身或者其父亲节点是否可以作为祖先节点呢?

    答案是肯定的,很简单,按照人的亲戚观念来说,你的父亲也是你的祖先,而LCA还可以将自己视为祖先节点

    举个例子吧,如下图所示最近公共祖先是2最近公共祖先最近公共祖先。 

    这就是最近公共祖先的基本概念了,那么我们该如何去求这个最近公共祖先呢?

    通常初学者都会想到最简单粗暴的一个办法:对于每个询问,遍历所有的点,时间复杂度为O(n*q),很明显,n和q一般不会很小

    常用的求LCA的算法有:Tarjan/DFS+ST/倍增

    后两个算法都是在线算法,也很相似,时间复杂度在O(logn)~O(nlogn)之间,我个人认为较难理解。

    有的题目是可以用线段树来做的,但是其代码量很大,时间复杂度也偏高,在O(n)~O(nlogn)之间,优点在于也是简单粗暴

    这篇博客主要是要介绍一下Tarjan算法(其实是我不会在线...)。

    什么是Tarjan(离线)算法呢?顾名思义,就是在一次遍历中把所有询问一次性解决,所以其时间复杂度是O(n+q)

    Tarjan算法的优点在于相对稳定,时间复杂度也比较居中,也很容易理解。

    下面详细介绍一下Tarjan算法的基本思路:

      1.任选一个点为根节点,从根节点开始。

      2.遍历该点u所有子节点v,并标记这些子节点v已被访问过。

      3.若是v还有子节点,返回2,否则下一步。

      4.合并v到u上。

      5.寻找与当前点u有询问关系的点v。

      6.若是v已经被访问过了,则可以确认u和v的最近公共祖先为v被合并到的父亲节点a。

    遍历的话需要用到dfs来遍历(我相信来看的人都懂吧...),至于合并,最优化的方式就是利用并查集来合并两个节点。

    下面上伪代码:

复制代码

   1 Tarjan(u)//marge和find为并查集合并函数和查找函数2 {3     for each(u,v)    //访问所有u子节点v4     {5         Tarjan(v);        //继续往下遍历6         marge(u,v);    //合并v到u上7         标记v被访问过;8     }9     for each(u,e)    //访问所有和u有询问关系的e10     {11         如果e被访问过;12         u,e的最近公共祖先为find(e);13     }14 }

复制代码

    个人感觉这样还是有很多人不太理解,所以我打算模拟一遍给大家看。

    建议拿着纸和笔跟着我的描述一起模拟!!

    假设我们有一组数据 9个节点 8条边 联通情况如下:

    1--2,1--3,2--4,2--5,3--6,5--7,5--8,7--9 即下图所示的树

    设我们要查找最近公共祖先的点为9--8,4--6,7--5,5--3;

    设f[]数组为并查集的父亲节点数组,初始化f[i]=i,vis[]数组为是否访问过的数组,初始为0; 

    下面开始模拟过程:

    取1为根节点往下搜索发现有两个儿子2和3;

    先搜2,发现2有两个儿子4和5,先搜索4,发现4没有子节点,则寻找与其有关系的点;

    发现6与4有关系,但是vis[6]=0,即6还没被搜过,所以不操作

    发现没有和4有询问关系的点了,返回此前一次搜索,更新vis[4]=1

    

    表示4已经被搜完,更新f[4]=2,继续搜5,发现5有两个儿子7和8;

    先搜7,发现7有一个子节点9,搜索9,发现没有子节点,寻找与其有关系的点;

    发现8和9有关系,但是vis[8]=0,即8没被搜到过,所以不操作;

    发现没有和9有询问关系的点了,返回此前一次搜索,更新vis[9]=1

    表示9已经被搜完,更新f[9]=7,发现7没有没被搜过的子节点了,寻找与其有关系的点;

    发现5和7有关系,但是vis[5]=0,所以不操作

    发现没有和7有关系的点了,返回此前一次搜索,更新vis[7]=1

    

    表示7已经被搜完,更新f[7]=5,继续搜8,发现8没有子节点,则寻找与其有关系的点;

    发现9与8有关系,此时vis[9]=1,则他们的最近公共祖先find(9)=5

      (find(9)的顺序为f[9]=7-->f[7]=5-->f[5]=5 return 5;)

    发现没有与8有关系的点了,返回此前一次搜索,更新vis[8]=1

 

    表示8已经被搜完,更新f[8]=5,发现5没有没搜过的子节点了,寻找与其有关系的点;

    

    发现7和5有关系,此时vis[7]=1,所以他们的最近公共祖先find(7)=5

      (find(7)的顺序为f[7]=5-->f[5]=5 return 5;)

    又发现5和3有关系,但是vis[3]=0,所以不操作,此时5的子节点全部搜完了;

    返回此前一次搜索,更新vis[5]=1,表示5已经被搜完,更新f[5]=2

    发现2没有未被搜完的子节点,寻找与其有关系的点;

    又发现没有和2有关系的点,则此前一次搜索,更新vis[2]=1

    

    表示2已经被搜完,更新f[2]=1,继续搜3,发现3有一个子节点6;

    搜索6,发现6没有子节点,则寻找与6有关系的点,发现4和6有关系;

    此时vis[4]=1,所以它们的最近公共祖先find(4)=1;

      (find(4)的顺序为f[4]=2-->f[2]=2-->f[1]=1 return 1;)

    发现没有与6有关系的点了,返回此前一次搜索,更新vis[6]=1,表示6已经被搜完了;

    

    更新f[6]=3,发现3没有没被搜过的子节点了,则寻找与3有关系的点;

    发现5和3有关系,此时vis[5]=1,则它们的最近公共祖先find(5)=1

      (find(5)的顺序为f[5]=2-->f[2]=1-->f[1]=1 return 1;)

    发现没有和3有关系的点了,返回此前一次搜索,更新vis[3]=1

    

    更新f[3]=1,发现1没有被搜过的子节点也没有有关系的点,此时可以退出整个dfs了。

    经过这次dfs我们得出了所有的答案,有没有觉得很神奇呢?是否对Tarjan算法有更深层次的理解了呢?

    

 

好了我们下面来增加两道例题

1.poj1330:传送门:http://poj.org/problem?id=1330

 这道题的题意就是直接问你两个点的最近公共祖先,直接上代码吧:

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;const int maxn = 10010;
vector<int> son[maxn];int fa[maxn];
int fas[maxn];
int root; 	//保存树的根节点 
bool vis[maxn];
int n;
int u,v;int find(int x){return fa[x]==x ? x : fa[x] = find(fa[x]);
}void init(){memset(vis,0,sizeof(vis));for(int i=1;i<=n;i++)	fa[i] = i;for(int i=0;i<=n;i++) 	son[i].clear();
} void tarjan_lca(int root){vis[root] = 1;for(int i=0;i<son[root].size();i++){int y = son[root][i];if(!vis[y]){if(y==u && vis[v]){cout <<find(v)<<'\n';return;}if(y==v && vis[u]){cout <<find(u)<<'\n';return;}tarjan_lca(y);fa[y] = root;}}
}int main()
{int T;cin >> T;while(T--){cin >>n;init();for(int i=0;i<n-1;i++){int a,b;cin >> a >> b;son[a].push_back(b);vis[b] = 1;} cin >> u >> v;for(int i =1;i<=n;i++){if(!vis[i]){root = i;break;}}memset(vis,0,sizeof(vis));tarjan_lca(root);}return 0;
}

2.hdu2586:传送门:http://acm.hdu.edu.cn/showproblem.php?pid=2586

 题意:给一个无根树,有q个询问,每个询问两个点,问两点的距离。求出  lca = LCA(X,Y) , 然后  dir[x] + dir[y] - 2 * dir[lca]

dir[u]表示点u到树根的距离,代码如下:

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;const int MAX = 40020;struct edge{int v,w;
}; 
vector<edge> mp[MAX];
vector<edge> query[MAX];
int vis[MAX];
int pre[MAX],father[MAX],path[MAX];int find(int x){return x==pre[x] ? x : pre[x] = find(pre[x]); 
}void LCA(int k){for(int i=0;i<mp[k].size();i++){int a = mp[k][i].v;if(!vis[a]){vis[a] = 1;path[a] = path[k] + mp[k][i].w;LCA(a);pre[a] = k;for(int j=0;j<query[a].size();j++){int b=query[a][j].v;if(vis[b]&&father[query[a][j].w]==-1){if(a==b)	father[query[a][j].w]=0;else	father[query[a][j].w]=path[a]+path[b]-2*path[find(b)];}}}}
}int main()
{int T;cin >> T;while(T--){int n,m;cin >> n >> m;for(int i=1;i<=n;i++){mp[i].clear();query[i].clear();vis[i]=0;father[i]=-1;pre[i]=i;path[i]=0;}int a,b,c;edge X;for(int i=1;i<n;i++){cin >> a >> b >> c;X.v=b;X.w=c;mp[a].push_back(X);X.v=a;mp[b].push_back(X);}for(int i=1;i<=m;i++){cin >>a >> b;X.v=b;X.w=i;query[a].push_back(X);X.v=a;query[b].push_back(X); }vis[1] = 1;LCA(1);for(int i=1;i<=m;i++){cout << father[i]<<'\n';}}return 0;
} 

 

这篇关于最近公共祖先LCA(Tarjan(离线)算法)amp;amp; poj1330 amp;amp; hdu2586的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/537843

相关文章

SpringBoot实现MD5加盐算法的示例代码

《SpringBoot实现MD5加盐算法的示例代码》加盐算法是一种用于增强密码安全性的技术,本文主要介绍了SpringBoot实现MD5加盐算法的示例代码,文中通过示例代码介绍的非常详细,对大家的学习... 目录一、什么是加盐算法二、如何实现加盐算法2.1 加盐算法代码实现2.2 注册页面中进行密码加盐2.

Java时间轮调度算法的代码实现

《Java时间轮调度算法的代码实现》时间轮是一种高效的定时调度算法,主要用于管理延时任务或周期性任务,它通过一个环形数组(时间轮)和指针来实现,将大量定时任务分摊到固定的时间槽中,极大地降低了时间复杂... 目录1、简述2、时间轮的原理3. 时间轮的实现步骤3.1 定义时间槽3.2 定义时间轮3.3 使用时

如何通过Golang的container/list实现LRU缓存算法

《如何通过Golang的container/list实现LRU缓存算法》文章介绍了Go语言中container/list包实现的双向链表,并探讨了如何使用链表实现LRU缓存,LRU缓存通过维护一个双向... 目录力扣:146. LRU 缓存主要结构 List 和 Element常用方法1. 初始化链表2.

SpringBoot自定义注解如何解决公共字段填充问题

《SpringBoot自定义注解如何解决公共字段填充问题》本文介绍了在系统开发中,如何使用AOP切面编程实现公共字段自动填充的功能,从而简化代码,通过自定义注解和切面类,可以统一处理创建时间和修改时间... 目录1.1 问题分析1.2 实现思路1.3 代码开发1.3.1 步骤一1.3.2 步骤二1.3.3

Python依赖库的几种离线安装方法总结

《Python依赖库的几种离线安装方法总结》:本文主要介绍如何在Python中使用pip工具进行依赖库的安装和管理,包括如何导出和导入依赖包列表、如何下载和安装单个或多个库包及其依赖,以及如何指定... 目录前言一、如何copy一个python环境二、如何下载一个包及其依赖并安装三、如何导出requirem

golang字符串匹配算法解读

《golang字符串匹配算法解读》文章介绍了字符串匹配算法的原理,特别是Knuth-Morris-Pratt(KMP)算法,该算法通过构建模式串的前缀表来减少匹配时的不必要的字符比较,从而提高效率,在... 目录简介KMP实现代码总结简介字符串匹配算法主要用于在一个较长的文本串中查找一个较短的字符串(称为

通俗易懂的Java常见限流算法具体实现

《通俗易懂的Java常见限流算法具体实现》:本文主要介绍Java常见限流算法具体实现的相关资料,包括漏桶算法、令牌桶算法、Nginx限流和Redis+Lua限流的实现原理和具体步骤,并比较了它们的... 目录一、漏桶算法1.漏桶算法的思想和原理2.具体实现二、令牌桶算法1.令牌桶算法流程:2.具体实现2.1

最长公共子序列问题的深度分析与Java实现方式

《最长公共子序列问题的深度分析与Java实现方式》本文详细介绍了最长公共子序列(LCS)问题,包括其概念、暴力解法、动态规划解法,并提供了Java代码实现,暴力解法虽然简单,但在大数据处理中效率较低,... 目录最长公共子序列问题概述问题理解与示例分析暴力解法思路与示例代码动态规划解法DP 表的构建与意义动

Python中的随机森林算法与实战

《Python中的随机森林算法与实战》本文详细介绍了随机森林算法,包括其原理、实现步骤、分类和回归案例,并讨论了其优点和缺点,通过面向对象编程实现了一个简单的随机森林模型,并应用于鸢尾花分类和波士顿房... 目录1、随机森林算法概述2、随机森林的原理3、实现步骤4、分类案例:使用随机森林预测鸢尾花品种4.1

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例,告诉我们不懂推荐算法的产品,也能从产品侧出发, 设计出一款不错的推荐系统。 相信很多新手产品,看到算法二字,多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法(注:传统是指科班出身的产品都会接触过)。但对于推荐算法,多数产品对着网上搜到的资源,都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后,更是加大了理解的难度。 但,不了解推荐算法,就无法做推荐系