【HDU 2586】【LCA总结】Tarjan | ST表RMQ | 倍增 | 树链剖分 | 树上多源最短路 | E

最新推荐文章于 2021-11-30 11:48:28 发布

Keyu Tian

最新推荐文章于 2021-11-30 11:48:28 发布

阅读量445

点赞数 2

本文链接：https://blog.csdn.net/weixin_42102584/article/details/89284845

版权

S | 搜索同时被 3 个专栏收录

15 篇文章 0 订阅

订阅专栏

Z | 总结题型

13 篇文章 0 订阅

订阅专栏

D | DP(其他)

7 篇文章 0 订阅

订阅专栏

以【HDU 2586】How far away ？为例，介绍LCA的四种求法：倍增、RMQ、树剖和Tarjan（~~怎么又是你~~ ）

【HDU 2586】How far away ？

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 27693 Accepted Submission(s): 11091

Tags：LCA Tarjan 树链剖分 树上多源最短路 ST表求RMQ

题目描述

给定一棵无向树，有 $q$ 次查询，每次询问两个结点的最短路距离。

输入

$T$ 组。第一行输入 $T$ 代表组数。

对于每组数据，第一行输入 $n\ \ q$ ，分别代表树结点数和询问次数，

接下来 $n - 1$ 行每行三个数 $u\ \ v\ \ d$ ，分别代表一条边连接的两个点和路径长度

接下 $q$ 行每行两个数 $u$ 和 $v$ ，代表每次询问

范围： $\le n \le 40000，1 \le q \le 200，1 \le d_i \le 40000$

输出

对于每次询问，输出一行一个数，即两结点的最短路距离

输入样例

输出样例

分析

LCA与树上多源最短路

LCA，最近公共祖先，顾名思义就是树上两个结点往根回溯出的两条链表的第一个交点。

那么这货跟树上多源最短路有什么关系呢？想象一下就能发现，树上任意两个结点的最短路径距离可以利用 LCA 来这样表示：

在这里插入图片描述

因此我们只要知道两个结点的 LCA，就可以在 $O (1)$ 内查到两点的最短距离啦！

求 LCA

所以关键就变成了如何求LCA。

一般来说求LCA常用的有四种方法：

① 离线回答询问的 Tarjan ：

利用 中序DFS 的性质：在访问过 $u$ 之后、访问到 $v$ 之前，必会经过它们的 LCA。如果我们再利用 并查集 维护一下 DFS 过程中拥有的子节点已经全部访问过的结点的父亲是谁，那么就可以在访问到 $v$ 的时候，通过查询 $u$ 的最远祖先结点而求得 $u 、 v$ 的 LCA（也就是从 $u$ 往上回溯，最上面的、子节点未访问完全的那个结点就是 $u 、 v$ 的 LCA）。

② 在线回答询问的 RMQ ：

为什么 RMQ 可以用于求 LCA？还是利用了中序DFS 的性质：在访问过 $u$ 之后、访问到 $v$ 之前，必会经过它们的 LCA。很显然，LCA 就是在首次访问 $u$ 和首次访问 $v$ 之间的一段 DFS序 中，DFS 序号最小者。这正是 RMQ。
利用 ST表（在 这篇Blog 中有详细介绍），可以在 $O(n\log n)$ 内预处理，然后 $O (1)$ 查询 DFS 序的 RMQ。

③ 在线回答询问的倍增：

④ 在线回答询问的 树链剖分 ：

时间复杂度

① Tarjan， $O (n + q)$ 的。
② ST表 RMQ， $O(n\log n+q)$ 的。
② 倍增， $O ()$ 的。
② 树剖， $O ()$ 的。

AC代码

① Tarjan

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define LL long long
#define _BS 1048576
char _bf[_BS];
char *__p1=_bf,*__p2=_bf;
#define _IO char *_p1=__p1,*_p2=__p2;
#define _OI __p1=_p1,__p2=_p2;

//#define GC getchar()
#define GC (_p1==_p2&&(_p2=(_p1=_bf)+fread(_bf,1,_BS,stdin),_p1==_p2)?EOF:*_p1++)
#define PC putchar
#define _Q_(x) {register char _c=GC,_v=1;for(x=0;_c<48||_c>57;_c=GC)if(_c==45)_v=-1;
#define _H_(x) for(;_c>=48&&_c<=57;x=(x<<1)+(x<<3)+_c-48,_c=GC);if(_v==-1)x=-x;}
#define sc(x) _Q_(x)_H_(x)
#define se(x) _Q_(x)else if(_c==EOF)return 0;_H_(x)

template<class T>
void PRT(const T _){if(_<0){PC(45),PRT(-_);return;}if(_>=10)PRT(_/10);PC(_%10+48);}
template<class T>
void UPRT(const T _){if(_>=10)UPRT(_/10);PC(_%10+48);}

constexpr int MV(4e4+7), ME(2*MV);


struct Ed1
{
	int next, v;
	unsigned d;
} ed1[ME];
int head1[MV], tot1;

struct Ed2
{
	int next, v;
} ed2[ME];
int head2[MV], tot2;
#define edd1(uu, vv, dd) ed1[++tot1].next=head1[uu], ed1[tot1].v=vv, ed1[tot1].d=dd, head1[uu]=tot1
#define edd2(uu, vv) ed2[++tot2].next=head2[uu], ed2[tot2].v=vv, head2[uu]=tot2


int uf[MV];
inline int find(const int x)
{
	return uf[x] == x ? x : uf[x] = find(uf[x]);
}


char vis[MV];
int ans[MV];
unsigned dis[MV];
void dfs(const int u)
{
	vis[u] = true, uf[u] = u;

	for (int i=head2[u]; i; i=ed2[i].next)
	{
		const int v = ed2[i].v;
		if (vis[v])
		{
			const int lca = find(v);
			ans[(i+1)>>1] = dis[u] - dis[lca] + dis[v] - dis[lca];
		}
	}

	for (int i=head1[u]; i; i=ed1[i].next)
	{
		const int v = ed1[i].v;
		if (!vis[v])
			dis[v] = dis[u] + ed1[i].d, dfs(v), uf[v] = u;
	}
}



int main()
{
	_IO

	int CASE;
	sc(CASE)
	while (CASE--)
	{
		int V, T, Q, ROOT, u, v;
		unsigned d;
		sc(V)sc(Q)

		tot1 = tot2 = 0,
		memset(head1, 0, sizeof(*head1) * (V+1)),
		memset(head2, 0, sizeof(*head2) * (V+1)),
		memset(vis, 0, sizeof(*vis) * (V+1));

		T = V - 1;
		while (T--)
		{
			sc(u)sc(v)sc(d)
			edd1(u, v, d);
			edd1(v, u, d);
		}

		T = Q;
		while (T--)
		{
			sc(u)sc(v)
			edd2(u, v);
			edd2(v, u);
		}

		dis[1] = 0,
		dfs(1);

		for (int i=1; i<=Q; ++i)
			UPRT(ans[i]), PC(10);
	}

	return 0;
}

② ST表 RMQ

注意 $R M Q$ 比大小的时候不是比编号，是比编号对应的深度

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define LL long long
#define _BS 1048576
char _bf[_BS];
char *__p1=_bf,*__p2=_bf;
#define _IO char *_p1=__p1,*_p2=__p2;
#define _OI __p1=_p1,__p2=_p2;

//#define GC getchar()
#define GC (_p1==_p2&&(_p2=(_p1=_bf)+fread(_bf,1,_BS,stdin),_p1==_p2)?EOF:*_p1++)
#define PC putchar
#define _Q_(x) {register char _c=GC,_v=1;for(x=0;_c<48||_c>57;_c=GC)if(_c==45)_v=-1;
#define _H_(x) for(;_c>=48&&_c<=57;x=(x<<1)+(x<<3)+_c-48,_c=GC);if(_v==-1)x=-x;}
#define sc(x) _Q_(x)_H_(x)
#define se(x) _Q_(x)else if(_c==EOF)return 0;_H_(x)

template<class T>
void PRT(const T _){if(_<0){PC(45),PRT(-_);return;}if(_>=10)PRT(_/10);PC(_%10+48);}
template<class T>
void UPRT(const T _){if(_>=10)UPRT(_/10);PC(_%10+48);}

constexpr int MV(4e4+7), ME(2*MV);
constexpr int MN(2*MV);


struct Ed
{
	int next, v;
	unsigned d;
} ed[ME];
int head[MV], tot;
#define edd(uu, vv, dd) ed[++tot].next=head[uu], ed[tot].v=vv, ed[tot].d=dd, head[uu]=tot;


unsigned dis[MV], de[MV];
int dfn[2*MV], time;
int first[MV];
void dfs(const int u, const int fa)
{
	dfn[++time] = u, first[u] = time, de[u] = de[fa] + 1;

	for (int i=head[u]; i; i=ed[i].next)
	{
		const int v = ed[i].v;
		if (!first[v])
			dis[v] = dis[u] + ed[i].d, dfs(v, u), dfn[++time] = u;
	}
}


namespace RMQ
{
constexpr int POW2[]{0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000, 0x20000, 0x40000, 0x80000, 0x100000, 0x200000, 0x400000, 0x800000, 0x1000000, 0x2000000, 0x4000000, 0x8000000, 0x10000000, 0x20000000, 0x40000000};
typedef int vint;
#define LOG2(x) (31-__builtin_clz(x))

vint dp[LOG2(MN) + 3][MN];

void dpd(void)
{
	memset(dp, 0, sizeof(dp));
	memcpy(dp[0]+1, dfn+1, sizeof(*dfn) * time);

	int kk = LOG2(time);
	for (int k=1; k<=kk; ++k)
	{
		int max_left = time-POW2[k-1];
		for (int left=1; left<=max_left; ++left)
			dp[k][left] = de[dp[k-1][left]] < de[dp[k-1][left + POW2[k-1]]] ? dp[k-1][left] : dp[k-1][left + POW2[k-1]];
	}
}

inline vint min(const int l, const int r)
{
	int kk = LOG2(r-l+1);
	return de[dp[kk][l]] < de[dp[kk][r+1-POW2[kk]]] ? dp[kk][l] : dp[kk][r+1-POW2[kk]];
}
}



int main()
{
	_IO

	int CASE;
	sc(CASE)
	while (CASE--)
	{
		int V, T, Q, ROOT, u, v;
		unsigned d;
		sc(V)sc(Q)

		tot = time = 0,
		memset(head, 0, sizeof(*head) * (V+1)),
		memset(first, 0, sizeof(*first) * (V+1));

		T = V - 1;
		while (T--)
		{
			sc(u)sc(v)sc(d)
			edd(u, v, d);
			edd(v, u, d);
		}

		dis[1] = 0, dfs(1, 0);
		RMQ::dpd(); 

		T = Q;
		int lca, l, r;
		while (T--)
		{
			sc(u)sc(v)
			l = first[u], r = first[v];
			if (l > r)
			{
				int tp = l;
				l = r;
				r = tp;
			}

			lca = RMQ::min(l, r);
			UPRT(dis[u] - dis[lca] + dis[v] - dis[lca]), PC(10);
		}
	}

	return 0;
}

③ 倍增

④ 树剖

Keyu Tian

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【HDU 2586】【LCA总结】Tarjan | ST表RMQ | 倍增 | 树链剖分 | 树上多源最短路 | E

以【HDU 2586】How far away ？为例，介绍LCA的四种求法：倍增、RMQ、树剖和Tarjan（怎么又是你）题目描述给定一棵无向树，有 $q$ 次查询，每次询问两个结点的最短路距离。
复制链接

扫一扫