tarjan 离线求 lca （专题）

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

离线LCA的求法，相信大家都知道使用tarjan。该方法确实很巧妙，利用dfs的性质，假设u的父亲为fa，当以u为根节点的子树被访问完之后，那么任何与u同属于同一个父亲fa并且不包含在u的子树内的点，与u子树内的任何一个点的最近公共祖先一定是fa，我们使用并查集维护同属一个ancestor的定点集合。


HDU 2586 How Far Away?

这道题是说给你一棵树，询问任意两点之间的最短距离。

显然dis[u][v] = (dep[u] - dep[lca]) + (dep[v] - dep[lca])，其中dep[u]表示u点到root的距离。

于是先dfs预处理dep数组，然后使用tarjan离线求解u and v之间的lca，并且记录结果。

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <cstring>

using namespace std;

const int NMAX = 40010;

typedef struct NODE
{
	int v, dis;
	NODE(int tv, int tdis)
	{
		v = tv;
		dis = tdis;
	}
}Node;

vector<Node> adj[NMAX];

typedef struct QUERY_NODE
{
	int v, index;
	QUERY_NODE(int tv, int tindex)
	{
		v = tv;
		index = tindex;
	}

}QueryNode;

vector<QueryNode> query[NMAX];

int ancestor[NMAX];
int tree[NMAX];
bool vis[NMAX];
int dep[NMAX];

int find(int u)
{
	int r = u;
	while(tree[r] != r)
	{
		r = tree[r];
	}

	while(u != r)
	{
		int temp = tree[u];
		tree[u] = r;
		u = temp;
	}
	return r;
}

void init()
{
	memset(vis, false, sizeof(vis));
	for(int i=0; i<NMAX; i++)
	{
		adj[i].clear();
		query[i].clear();
	}
}

void tarjan(int fa, int u)
{
	tree[u] = u;
	//vis[u] = true;
	int len = adj[u].size();
	for(int i=0; i<len; i++)
	{
		int v = adj[u][i].v;
		if(v != fa)
		{
			tarjan(u, v);
			tree[find(v)] = u;
		}
	}

	vis[u] = true;

	len = query[u].size();
	for(int i=0; i<len; i++)
	{
		int v = query[u][i].v;
		int index = query[u][i].index;
		if(vis[v])
		{
			ancestor[index] = find(v);
			int lca = ancestor[index];
			ancestor[index] = (dep[u]-dep[lca]) + (dep[v] - dep[lca]);
			//printf("%d %d %d %d\n", u, v, lca, ancestor[index]);
		}
	}
}

int getDis(int fa, int u)
{
	int len = adj[u].size();
	for(int i=0; i<len; i++)
	{
		int v = adj[u][i].v;
		int dis = adj[u][i].dis;
		if(v != fa)
		{
			dep[v] = dep[u] + dis;
			getDis(u, v);
		}
	}
}

int main()
{
	//freopen("data.in", "r", stdin);
	int T;
	scanf("%d", &T);
	
	int n, k;
	while(T--)
	{
		scanf("%d%d", &n, &k);
		init();
		int u, v, w;
		for(int i=1; i<n; i++)
		{
			scanf("%d%d%d", &u, &v, &w);
			adj[u].push_back(Node(v, w));
			adj[v].push_back(Node(u, w));
		}
		for(int i=0; i<k; i++)
		{
			scanf("%d%d", &u, &v);
			query[u].push_back(QueryNode(v, i));
			query[v].push_back(QueryNode(u, i));
		}

		memset(dep, 0, sizeof(dep));

		getDis(-1, 1);
		tarjan(-1, 1);
		for(int i=0; i<k; i++)
			printf("%d\n", ancestor[i]);
	}
	return 0;
}

HDU 2874 connections between cities

这道题何上一题差不多，题意是说：给了你很多棵树，询问任意两点：如果不在同一棵树，那么输出not connected；否则输出两点之间的距离，和上一题做法一样。

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <cstring>

using namespace std;

const int NMAX = 10010;

typedef struct NODE
{
	int v, dis;
	NODE(int tv, int tdis)
	{
		v = tv;
		dis = tdis;
	}
}Node;

vector<Node> adj[NMAX];

typedef struct QUERY_NODE
{
	int v, index;
	QUERY_NODE(int tv, int tindex)
	{
		v = tv;
		index = tindex;
	}

}QueryNode;

vector<QueryNode> query[NMAX];

int ancestor[1000006];
int tree[NMAX];
bool vis[NMAX], visited[NMAX];
int dep[NMAX];

int find(int u)
{
	int r = u;
	while(tree[r] != r)
	{
		r = tree[r];
	}

	while(u != r)
	{
		int temp = tree[u];
		tree[u] = r;
		u = temp;
	}
	return r;
}

void init()
{
	memset(visited, false, sizeof(visited));
	for(int i=0; i<NMAX; i++)
	{
		adj[i].clear();
		query[i].clear();
	}
}

void tarjan(int fa, int u)
{
	visited[u] = true;

	tree[u] = u;
	int len = adj[u].size();
	for(int i=0; i<len; i++)
	{
		int v = adj[u][i].v;
		if(v != fa)
		{
			tarjan(u, v);
			tree[find(v)] = u;
		}
	}

	vis[u] = true;

	len = query[u].size();
	for(int i=0; i<len; i++)
	{
		int v = query[u][i].v;
		int index = query[u][i].index;
		if(vis[v])
		{
			ancestor[index] = find(v);
			int lca = ancestor[index];
			ancestor[index] = (dep[u]-dep[lca]) + (dep[v] - dep[lca]);
			//printf("%d %d %d %d\n", u, v, lca, ancestor[index]);
		}
	}
}

int getDis(int fa, int u)
{
	int len = adj[u].size();
	for(int i=0; i<len; i++)
	{
		int v = adj[u][i].v;
		int dis = adj[u][i].dis;
		if(v != fa)
		{
			dep[v] = dep[u] + dis;
			getDis(u, v);
		}
	}
}

int main()
{
	//freopen("data.in", "r", stdin);
	
	int n, m, k;
	while(scanf("%d%d%d", &n, &m, &k) != EOF)
	{
		init();
		int u, v, w;
		for(int i=0; i<m; i++)
		{
			scanf("%d%d%d", &u, &v, &w);
			adj[u].push_back(Node(v, w));
			adj[v].push_back(Node(u, w));
		}
		for(int i=0; i<k; i++)
		{
			scanf("%d%d", &u, &v);
			query[u].push_back(QueryNode(v, i));
			query[v].push_back(QueryNode(u, i));
		}

		memset(dep, 0, sizeof(dep));
		memset(ancestor, -1, sizeof(ancestor));

		for(int i=1; i<=n; i++)
		{
			if(!visited[i])
			{
				memset(vis, false, sizeof(vis));
				getDis(-1, i);
				tarjan(-1, i);
			}
		}
		for(int i=0; i<k; i++)
		{
			if(ancestor[i] == -1)
				printf("Not connected\n");
			else
				printf("%d\n", ancestor[i]);
		}
	}
	return 0;
}

HDU 4547 CD操作

这道大水题，被坑爹了。输入的查询中存在之前目录中没有出现的点，然后就是输入肯定是保证这两个没有出现过的点相同，所以初始化的时候将答案全初始化为0就行了。

坑爹了……

奉上代码吧。

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <map>
using namespace std;

const int MAX = 100010;

vector<int> adj[MAX];
vector<int> queryid[MAX];
int dep[MAX], ans[MAX];
bool vis[MAX];

typedef struct QUERY
{
	int a, b;
	QUERY(){}
	QUERY(int ta, int tb)
	{
		a = ta;
		b = tb;
	}
}Query;

Query query[MAX];

map<string, int> hash_name;
void tarjan(int root);

void init(int n, int m)
{
	memset(vis, false, sizeof(vis));
	hash_name.clear();
	for(int i=1; i<MAX; i++)
	{
		adj[i].clear();
		queryid[i].clear();
	}
	
	char sa[50], sb[50];
	int cnt = 0;
	int u, v;
	for(int i=1; i<n; i++)
	{
		scanf("%s %s", sa, sb);
		if(hash_name[sa] == 0)
			hash_name[sa] = ++cnt;
		u = hash_name[sa];
		if(hash_name[sb] == 0)
			hash_name[sb] = ++cnt;
		v = hash_name[sb];
		adj[v].push_back(u);
		vis[u] = true;
	}

	for(int i=0; i<m; i++)
	{
		scanf("%s %s", sa, sb);
		if(hash_name[sa] == 0)
			hash_name[sa] = ++cnt;
		u = hash_name[sa];
		if(hash_name[sb] == 0)
			hash_name[sb] = ++cnt;
		v = hash_name[sb];
		query[i] = Query(u, v);
		queryid[u].push_back(i);
		queryid[v].push_back(i);
	}

	
	memset(ans, 0, sizeof(ans));
	int root;
	for(int i=1; i<=n; i++)
	{
		if(!vis[i])
		{
			root = i;
			break;
		}
	}
	memset(vis, false, sizeof(vis));
	tarjan(root);
}

int tree[MAX];
int find(int u)
{
	int root = u;
	while(tree[root] != root)
		root = tree[root];
	while(u != root)
	{
		int temp = tree[u];
		tree[u] = root;
		u = temp;
	}
	return root;
}

void tarjan(int u)
{
	int len = adj[u].size();
	tree[u] = u;
	for(int i=0; i<len; i++)
	{
		int v = adj[u][i];
		dep[v] = dep[u]+1;
		tarjan(v);
		tree[find(v)] = u;
	}
	vis[u] = true;

	len = queryid[u].size();
	for(int i=0; i<len; i++)
	{
		int id = queryid[u][i];
		int a = query[id].a;
		int b = query[id].b;

		int lca;
		if(u == a)
			lca = find(b);
		else
			lca = find(a);
		ans[id] = dep[a] - dep[lca];
		if(lca != b)
			ans[id]++;
	}
}

int main()
{
	int T;
	scanf("%d", &T);
	while(T--)
	{
		int n, m;
		scanf("%d%d", &n, &m);
	
		init(n, m);

		for(int i=0; i<m; i++)
			printf("%d\n", ans[i]);
	}
	return 0;
}


小小程序师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Tarjan离线算法 （LCA最近公共祖先）
bestsort
08-03 1436
Tarjan离线算法是利用并查集和DFS来达到离线处理的目的 我们都知道，对于一棵树，后序遍历一遍，访问它的根的时机一定是后与它的孩子的。换一句话，当开始遍历它的根节点的时候，它遍历过的孩子的公共祖先一定是这个根而这也就成为了我们解题的思想。 由于是需要对整树进行DFS，所以Tarjan需要在所有信息都输入完毕后才能进行操作，这也是为什么要离线的原因 在线是能动态修改查询，比如线段树就...
Tarjan 的 LCA 算法
03-19
**Tarjan的LCA算法详解** 最近公共祖先（Lowest Common Ancestor，简称LCA）是图论中的一个重要概念，特别是在树形结构中。在树中，两个节点的最近公共祖先指的是距离根节点最近的那个同时是这两个节点的祖先的节点...
Tarjan 离线求LCA
weixin_34365417的博客
06-13 139
#include<bits/stdc++.h> using namespace std; const int maxn=450005; struct node{ int nxt; int to; }tree[maxn*2]; struct node1{ int LCA; int nxt; int to; }qtree[m...
Tarjan—离线求LCA
weixin_62224014的博客
10-29 769
针对有询问的题目，在线做法为读入一个询问立刻给出输出；离线做法为读入所有询问后再给出输出。
Tarjan离线求lca
jziwjxjd的博客
03-30 229
这篇博客写的非常好 tarjan步骤 ①.任选一个点为根节点，从根节点开始。 ②.遍历该点u所有子节点v，并标记这些子节点v已被访问过。 ③.若是v还有子节点，返回2，否则下一步。 ④.合并v到u上。 ⑤.寻找与当前点u有询问关系的点v。 ⑥.若是v已经被访问过了，则可以确认u和v的最近公共祖先为v被合并到的父亲节点。 来洛谷交一发~ #include <bits/stdc++.h> using namespace std; const int maxn = 2e6+10; struct edg
Tarjan入门⑤离线求LCA
qq_35577488的博客
11-19 169
前言： md，感觉LCA上我的学习顺序正好反过来了。先学的ST+欧拉序，后学的倍增。最后才学的Tarjan求LCA。 这个算法唯一不足就是离线的，但是一大好处就是实现起来超级简单。理解起来也很简单. 本质上就是一个dfs。 我们对每一个点开一个vector存询问。对于任意两个点u,vu,vu,v。dfs的时候要么先遍历u再遍历v.要么反之。所以我们需要对u,vu,vu,v都插入询问。 当访问到vvv时,若uuu已经被访问了，那么LCA(u,v)LCA(u,v)LCA(u,v)这个点一定是被访问且未结束访问的
contest_tarjan_LCA_源码
10-03
然而，Tarjan的离线LCA算法则是在预处理阶段就计算出所有可能的节点对的LCA，从而在查询时能快速获取结果。这种算法适用于有大量预知查询的情况，可以显著提高效率。 Tarjan算法的核心思想是深度优先搜索（DFS）...
Tarjan应用LCA
07-15
标签"TarjanLCA"表明这里讨论的是一种特定的LCA算法，即由Robert Tarjan提出的算法。Tarjan算法通常用于解决离线问题，即在程序开始前收集所有待查询的节点对，然后从树的根节点开始执行。在处理过程中，Tarjan算法...
LCA.zip_lca Tarjan pascal_lca pascal_tarjan lca pascal
09-14
在本例中，提供的压缩包文件"LCA.zip"包含了使用Pascal语言实现的Tarjan算法来解决最近公共祖先问题的代码。 Tarjan算法是由Robert Endre Tarjan设计的一种高效算法，主要用于解决图的深度优先搜索（DFS）和强连通...
tarjan求割边
07-15
Tarjan算法求割边 Tarjan算法是图论中的一种常见算法，用于寻找有向图中的割点和割边。割边是指删除该边后，图将被分割成两个或多个连通分量的边。 Tarjan算法可以快速地找到所有的割边。 割边的定义与割点的定义...
LCA 最近公共祖先 tarjan离线 总结 结合3个例题
热门推荐
hnust_xiehonghao的专栏
06-18 1万+
在网上找了一些对tarjan算法解释较好的文章 并加入了自己的理解   LCA（Least Common Ancestor），顾名思义，是指在一棵树中，距离两个点最近的两者的公共节点。也就是说，在两个点通往根的道路上，肯定会有公共的节点，我们就是要求找到公共的节点中，深度尽量深的点。还可以表示成另一种说法，就是如果把树看成是一个图，这找到这两个点中的最短距离。       LCA
tarjan离线求lca
xhk2000的专栏
08-30 323
lca即为最近公共祖先，通过dfs遍历一棵树即可无顺序地求出lca 思路：先找出根节点，用有向边连树，进行dfs，因为每个节点最多被遍历一次，因此复杂度为O（n）； 运用并查集，在遍历子树的时候将子树中所有的元素连接到子树的根节点上，此处需要用到并查集，因为并查集时间复杂度极小。 注意，是在回溯时才进行连接，因为如果在遍历时进行，则无法查到现在的lca，因为所有的节点都被连接在了第一个根节点
（算法）Tarjan离线算法解决LCA问题 （附POJ 1470 Closest Common Ancestors 代码）
Bright
07-15 7745
对于最近公共祖先问题，我们先来看这样一个性质，当两个节点（u，v）的最近公共祖先是x时，那么我们可以确定的说，当进行后序遍历的时候，必然先访问完x的所有子树，然后才会返回到x所在的节点。这个性质就是我们使用Tarjan算法解决最近公共祖先问题的核心思想。      同时我们会想这
Tarjan算法离线求LCA
m0_37579232的博客
04-15 235
最近学习了Tarjan离线求LCA，写篇博客记录一下： 先贴出来：学习博客（讲的很好很详细~） 1.定义： LCA（Lowest Common Ancestor）最近公共祖先，即树上两个点最新的公共祖先节点 比如：lca(1,4)=1; lca(4,5)=3; lca(2,3)=1; 2.伪码： Tarjan(u){ for each(u,v){//遍历每一个u的...
lca(tarjan离线）
xuwnehao的博客
03-11 153
预处理nlogn，查询o（1）； 【模板】最近公共祖先（LCA） - 洛谷 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=5e5+50; int n,m,s,uu,vv; int head[N]; int que[N]; int fa[N]; struct edge{ int to,nex; }ee[N<<1],ce[N<<1]; int...
Tarjan离线求LCA模板
vocaloid01的博客
08-26 592
Tarjan 算法求 LCA 的时间复杂度为 O(n+q) ，是一种离线算法，要用到并查集。 ps：时间复杂度其实还需要考虑并查集操作的时间复杂度 ，但是由于在多数情况下，路径压缩并查集的单次操作复杂度可以看做 O(1)，所以直接近似为 O(n+q) 。 const int MAXN = ;//最大点数 pair&lt;int,int&gt; P[205];//存询问边 int lca...
LCA的Tarjan离线算法
weixin_30553777的博客
08-16 111
LCA的Tarjan离线(offline)算法中，通过后序DFS遍历多叉树(结点数为n)，利用并查集算法(disjoint sets‘ union-find operations)，可以在线性时间O(n+|P|)内找到事先给定（即offline的含义）的|P|个成对结点的LCA。 具体做法如下： 1） 首先所有的结点通过makeSet(x)调用放到各自独立集合中，然后在用lca(u)递归...
离线tarjan算法求LCA
yiqzq的博客
08-11 172
#include &lt;cmath&gt; #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;algorithm&gt; #include &lt;cstring&gt; #include &lt;queue&gt; #include &lt;vector&gt; #include &lt;stack&
LCATarjan离线算法
Gloria971111的博客
08-14 680
怎么说离线算法呢，我觉得就是说你把想要询问的东西提前存起来了，这样在遍历然后顺便建树的过程中就可以随时回答这个问题，然后再进行相应的更新…http://www.cnblogs.com/JVxie/p/4854719.html ☝这个博主写得很不错，我就是这么看懂的。#include<iostream> using namespace std; #include<vector> #include<a
Tarjan求LCA
最新发布
07-27
Tarjan算法是一种用于解决最近公共祖先（LCA）问题的离线算法。离线算法指的是在读取所有查询之后一次性计算所有查询的答案，而不是每读取一个查询就计算一次。\[1\] 在Tarjan算法中，需要使用并查集来实现。并查集...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值