最近公共祖先 朴素 离线 在线 算法合集

最新推荐文章于 2020-07-18 23:28:20 发布
最新推荐文章于 2020-07-18 23:28:20 发布
阅读量1k 收藏
点赞数 1
分类专栏： 小算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Night_13/article/details/55517817
版权

描述

小Ho最近发现了一个神奇的网站！虽然还不够像58同城那样神奇，但这个网站仍然让小Ho乐在其中，但这是为什么呢？

“为什么呢？”小Hi如是问道，在他的观察中小Ho已经沉迷这个网站一周之久了，甚至连他心爱的树玩具都弃置一边。

“嘿嘿，小Hi，你快过来看！”小Ho招呼道。

“你看，在这个对话框里输入我的名字，在另一个对话框里，输入你的名字，再点这个查询按钮，就可以查出来……什么！我们居然有同一个祖祖祖祖祖爷爷？”

“诶，真是诶……这个网站有点厉害啊。”小Hi不由感叹道。

“是啊，这是什么算法啊，这么厉害！”小Ho也附和道。

“别2，我说的是他能弄到这些数据很厉害，而人类的繁殖树这种层数比较浅的树对这类算法的要求可是简单的不得了，你都能写出来呢！”小Hi道。

“啊？我也能写出来？可是……该从哪开始呢？”小Ho困惑了。

小Ho要面临的问题是这样的，假设现在他知道了N个人的信息——他们的父亲是谁，他需要对于小Hi的每一次提问——两个人的名字，告诉小Hi这两个人的是否存在同一个祖先，如果存在，那么他们的所有共同祖先中辈分最低的一个是谁？

输入

每个测试点（输入文件）有且仅有一组测试数据。

每组测试数据的第1行为一个整数N，意义如前文所述。

每组测试数据的第2~N+1行，每行分别描述一对父子关系，其中第i+1行为两个由大小写字母组成的字符串Father_i, Son_i，分别表示父亲的名字和儿子的名字。

每组测试数据的第N+2行为一个整数M，表示小Hi总共询问的次数。

每组测试数据的第N+3~N+M+2行，每行分别描述一个询问，其中第N+i+2行为两个由大小写字母组成的字符串Name1_i, Name2_i，分别表示小Hi询问中的两个名字。

对于100%的数据，满足N<=10^2，M<=10^2, 且数据中所有涉及的人物中不存在两个名字相同的人（即姓名唯一的确定了一个人）。

输出

对于每组测试数据，对于每个小Hi的询问，输出一行，表示查询的结果：如果根据已知信息，可以判定询问中的两个人存在共同的祖先，则输出他们的所有共同祖先中辈分最低的一个人的名字，否则输出-1。

样例输入 
11
JiaYan JiaDaihua
JiaDaihua JiaFu
JiaDaihua JiaJing
JiaJing JiaZhen
JiaZhen JiaRong
JiaYuan JiaDaishan
JiaDaishan JiaShe
JiaDaishan JiaZheng
JiaShe JiaLian
JiaZheng JiaZhu
JiaZheng JiaBaoyu
3
JiaBaoyu JiaLian
JiaBaoyu JiaZheng
JiaBaoyu LinDaiyu
样例输出 
JiaDaishan
JiaZheng
-1

1、朴素算法

小Hi道：“这个问题也应该是树结构许许多多问题中颇为经典的一个了，如果就简单的将父子关系视作树结构中的父子结点关系的话，这个问题其实就是在问树中两个结点层数最高的公共祖先——也就是所谓的最近公共祖先，而这个问题有非常多的解决方法，分别适合于不同的场景，像在线算法离线算法什么的现在说给你听你也不一定能够很快理解。”

“但是……你不是说我能够写出来的么？”小Ho纳闷了。

“所以说我们慢慢来不要急，先教你个最简单的法子。”小Hi如是说道。

“最简单的法子……如果数据量不大的话，我完全可以直接将这两个人的祖先全部找出来，然后取它们的交集，然后再找到其中辈分最低的一个不就行了。”小Ho思考了会这般说道。

小Hi点了点头道：“差不多就是这样！当然你也先将一个人的祖先全都标记出来，然后顺着另一个的父亲一直向上找，直到找到第一个被标记过的结点，便是它们的最近公共祖先结点了。”

“原来这么简单！”小Ho笑道：“那我先去写着了。”

#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <cctype>
#include <list>
#include <cmath>
#include <bitset>
#include <queue>
#include <stack>
#include <sstream>
#include <functional>
#include <cassert>
using namespace std;

int RL(char _str[], int _maxlen = 1e8) {
	if (fgets(_str, _maxlen, stdin) == NULL) return -1;
	int i = 0;
	while (_str[i]) ++i;
	if (_str[i - 1] == '\n') _str[--i] = 0;
	return i;
}

inline int RI() {
	int temp;
	scanf("%d", &temp);
	return temp;
}

inline long long RLL() {
	long long temp;
	scanf("%I64d", &temp);
	return temp;
}

inline double RD() {
	double temp;
	scanf("%lf", &temp);
	return temp;
}

template <class T1, class T2>
inline void Max(T1 &a, T2 b) { if (b > a) a = b; }

template <class T1, class T2>
inline void Min(T1 &a, T2 b) { if (b < a) a = b; }

typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef long long LL;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-8;
const int mod = 100007;
const int maxn = 100 + 9;

int N, M;

int main() {
	//std::ios::sync_with_stdio(0);
	//std::cin.tie(0);
#ifdef NIGHT_13
	freopen("in.txt", "r", stdin);
	//freopen("myout.txt", "w", stdout);
#endif
	int CAS = 0;
	int id = 1;
	map<string, string> par;
	scanf("%d", &N);
	while (N--) {
		char p1[100], p2[100];
		scanf("%s%s", p1, p2);
		par[p2] = p1;
	}
	scanf("%d", &M);
	while (M--) {
		char p1[100], p2[100];
		scanf("%s%s", p1, p2);
		string a(p1), b(p2);
		set<string> fa;
		fa.insert(a);
		while (par.find(a) != par.end()) {
			fa.insert(par[a]);
			a = par[a];
		}
		while (fa.find(b) == fa.end() && par.find(b) != par.end()) {
			b = par[b];
		}
		if (fa.find(b) != fa.end()) puts(b.c_str());
		else puts("-1");
	}
	return 0;
}


2、离线算法（tarjan）

“唔……我感觉你这个问题和上次提出的问题没有什么太大区别嘛，还简化了许多……那我就用上次的算法不行么？”小Ho疑问道。

“NoNoNo，仔细注意一下数据范围，这可不是上次的算法就能够解决的~”小Hi道。

“是诶，上次无论是人数还是询问数，都远远少于这一次的……那么我该如何进行计算呢？”小Ho不禁问道。

“我认为有这样两种法子，其中一种呢，就是将一段时间内的询问收集起来统一处理，利用一些与询问个数无关的算法来进行计算，这样时间复杂度在平摊到每个询问的时候就不会很高了。”小Hi缓缓道来。

“听起来很有道理。”

“就是很有道理好么！”小Hi道：“我们不妨再抽象这个问题，其实本质就是给你一棵树，然后每次询问是求这棵树种某两个结点的最近公共祖先——所有公共祖先中层数最深的。”

“是的！而且这个最近公共祖先怎么和之前那一次所说的转折点很类似啊？”小Ho似乎回忆起了什么往事。

“差不多一个意思把，重点是在于我接下来要说的——用于求解最近公共祖先问题的离线算法，为什么要叫做离线算法呢，因为我需要一次性收集若干个询问之后才能通过这个算法一同计算出这些询问的答案，而不能像一个在线系统一样对于每一个询问都即时的进行计算并给出答复。”小Hi解释道。

“你说了这么多，可我还是不知道这个算法是怎么回事呢！”小Ho抱怨道。

“别急，你看这个图——好吧，其实是棵树，代表着我们这个问题的一个输入，而这几个是我们要处理的询问。”小Hi在准备好的黑板上写写画画道。

“好的。”小Ho点点头。

“而我现在要做的呢，是以深度优先搜索的顺序来访问这棵树。”小Hi继续道：“在这个过程中，我会给这棵树的结点染色，一开始所有结点都是白色的。而当我第一次经过某个结点的时候，我会将它染成灰色，而当我第二次经过这个结点的时候——也就是离开这棵子树的时候，我会将它染成黑色。”

“但是这样做的意义何在呢？”小Ho的问题来了。

“举个例子，当我们深度优先搜索到A结点时，我们发现A结点和B结点是我们需要处理的一组询问。”小Hi在黑板上画着。

小Ho点了点头。

“这个时候，这个图的染色情况是这样的。”小Hi顺手就涂上了颜色，继续道：“我们这个时候就要去查看B结点的颜色——灰色，说明我们进入了以B结点为根的子树，但是还没有从这棵子树中出去，你知道这意味着什么吗？”

“意味着A结点在B结点所在的子树中——那么B结点就是A和B结点的最近公共祖先了？”小Ho答道。

“没错，但这只是一种简单的情况，如果我询问的不是A和B这两个结点，而是A和C这两个结点，那么在访问到A的时候，C的颜色是黑色的，这时候我该怎么处理呢？”小Hi继续问道。

“唔……首先肯定只能从所有灰色结点中找——这是A结点的所有祖先结点！那么……就是C结点向上的第一个灰色结点？”小Ho答道。

“是的，但是你这样做不会和上一次的朴素做法一样低效率么？”小Hi反问道。

“的确是的……每次都要向上找会很吃不消的。”小Ho困惑了：“那么我该怎么办呢？”

“先别着急，我们把之前的分情况讨论结束，再来细谈这个问题……那么接下来只有一种可能了，如果询问的时A和P这两个结点，而此时P还是白色的，你觉得怎么处理比较合适？”小Hi道。

“唔……我觉得把，既然这个时候P还是白色，那么就先不要管这个询问了，毕竟现在关于P的信息一点都不知道。而且反正深度优先搜索会处理到P结点，那个时候A结点肯定已经不是白色了，就可以沿用之前的方法进行解决了！”小Ho沉思了一会，答道。

“是的！那么你有没有发现，这样一遍处理下来，你就可以求出所有准备好的询问的结果了——我先计算每个结点涉及到的询问，然后在深度优先搜索的过程中对结点染色，如果发现当前访问的结点是涉及到某个询问，那么我就看这个询问中另一个结点的颜色，如果是白色，则留待之后处理，如果是灰色，那么最近公共祖先必然就是这个灰色结点，如果是黑色，那么最近公共祖先就是这个黑色结点向上的第一个灰色结点。”小Hi总结道：“而我们唯一剩下的问题，就是怎么样快速的找到一个黑色结点向上的第一个灰色结点。”

小Ho若有所思的点了点头。

“还记得上周我和你讲的并查集问题么？”小Hi问道。

“还记得呢！但是那和这个问题又有什么关系呢？”小Ho问道。

“我们来这样想，当深度优先搜索进行到刚刚第二次经过C结点这一步的时候，是不是以C为根的子树中所有结点，它们向上找的第一个灰色结点都是C结点？”小Hi没有直接回答小Ho的问题，反倒提出了一个新的问题。

“是的。”

“那么如果我们将C这棵子树视为一个集合，而将C结点视为这个集合的代表元素的话，那么我在第二次经过C结点之后，将C结点染成黑色后，以C为根的子树中的所有结点的代表元素——或者说向上找的第一个灰色结点都变成了C的父亲结点——D结点？那么这一过程，是不是其实就是将C结点代表的集合合并到了D结点代表的集合中去了？”小Hi问道。

“唔……还真是，每个结点最开始都是一个独立的集合，每当一个结点由灰转黑的时候，就将它所在的集合合并到其父亲结点所在的集合中去。这样无论什么时候，任意一个黑色结点所在集合的代表元素就是这个结点向上的第一个灰色结点！也就是说，我只要在深度优先搜索的过程中维护这样的一些集合，我就能够对于每一个黑色结点，非常快捷的求出在当前的染色状况下，它向上的第一个灰色结点。”小Ho惊道：“这么一来，之前遗留的问题就得到了解决。”

“是的呢！而之所以你可以这样做的原因，这是因为这样的染色是不可逆的，对于一个黑色结点来说，它向上找的第一个灰色结点只会越来越高——这和集合的性质是相似的！”

“原来是这样！”小Ho感慨道。

“所以你接下来要做的事情，就是在深度优先搜索的过程中，不断的给结点染色，同时维护好这样的一些集合，并且对于询问一一做出回答呢！”小Hi笑道：“这可是有点难度哦~”

“没事！这对我来说，可是小菜一碟呢！”

#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <cctype>
#include <list>
#include <cmath>
#include <bitset>
#include <queue>
#include <stack>
#include <sstream>
#include <functional>
#include <cassert>
using namespace std;

int RL(char _str[], int _maxlen = 1e8) {
	if (fgets(_str, _maxlen, stdin) == NULL) return -1;
	int i = 0;
	while (_str[i]) ++i;
	if (_str[i - 1] == '\n') _str[--i] = 0;
	return i;
}

inline int RI() {
	int temp;
	scanf("%d", &temp);
	return temp;
}

inline long long RLL() {
	long long temp;
	scanf("%I64d", &temp);
	return temp;
}

inline double RD() {
	double temp;
	scanf("%lf", &temp);
	return temp;
}

template <class T1, class T2>
inline void Max(T1 &a, T2 b) { if (b > a) a = b; }

template <class T1, class T2>
inline void Min(T1 &a, T2 b) { if (b < a) a = b; }

typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef long long LL;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-8;
const int mod = 100007;
const int maxn = 1e5 + 9;

int N, M, par[maxn];
map<string, int> id;
string name[maxn];
vector<int> G[maxn];
vector<pii> Q[maxn];
int lca[maxn];

int Find(int x) {
	if (par[x] == x) return x;
	return par[x] = Find(par[x]);
}

void LCA_Tarjan(int x, int p) {
	par[x] = x;
	for (int i = 0; i < G[x].size(); ++i) {
		if (G[x][i] != p) LCA_Tarjan(G[x][i], x);
	}
	for (int i = 0; i < Q[x].size(); ++i) {
		if (par[Q[x][i].first]) lca[Q[x][i].second] = Find(Q[x][i].first);
	}
	par[x] = p;
}

int main() {
	//std::ios::sync_with_stdio(0);
	//std::cin.tie(0);
#ifdef NIGHT_13
	freopen("in.txt", "r", stdin);
	//freopen("myout.txt", "w", stdout);
#endif
	int CAS = 0;
	int _id = 0;
	scanf("%d", &N);
	while (N--) {
		char p1[100], p2[100];
		scanf("%s%s", p1, p2);
		int ida, idb;
		if (!(ida = id[p1])) { ida = id[p1] = ++_id; name[_id] = p1; }
		if (!(idb = id[p2])) { idb = id[p2] = ++_id; name[_id] = p2; }
		G[ida].push_back(idb);
		G[idb].push_back(ida);
	}
	scanf("%d", &M);
	for (int i = 1; i <= M; ++i) {
		char p1[100], p2[100];
		scanf("%s%s", p1, p2);
		int a = id[p1], b = id[p2];
		Q[a].push_back(pii(b, i));
		Q[b].push_back(pii(a, i));
	}
	LCA_Tarjan(1, 0);
	for (int i = 1; i <= M; ++i) {
		puts(name[lca[i]].c_str());
	}
	return 0;
}


3、在线算法（RMQ-ST）

“那你快教我啊！”小Ho耐不住性子。

“不要急，且听我缓缓道来，还记得很久之前我和你说过的最近公共祖先其实就是这两个点连通路径上的那个折点么（参见hiho一下第十一周树的直径）”小Hi问道。

“记得！”

“这个折点也就是这2点所连路径上深度最小的那个点了！那么这个问题其实和我们之前所提到的那个求区间最小值的是不是差不多（参见hiho一下第十六周——RMQ-ST算法），只不过一个是在数组上的区间，一个是在树上的区间？”小Hi问道。

“你非要这么说那我只能说是啦。。但是树和数组还是差了挺远的吧。”小Ho表示汗颜。

小Hi点了点头，随即道：“那就这么弄一下，我从树的根节点开始进行深度优先搜索，每次经过某一个点——无论是从它的父亲节点进入这个点，还是从它的儿子节点返回这个点，都按顺序记录下来。这样，是不是就把一棵树转换成了一个数组？而找到树上两个节点的最近公共祖先，无非就是找到这两个节点最后一次出现在数组中的位置所囊括的一段区间中深度最小的那个点？”

小Ho显然是没有料到小Hi还有这一招，一上来也是感觉明显就不对嘛，毕竟好好的树怎么随便就弄成数组了不是，但是静下心来仔细想想：“从第一个点离开（返回它的父亲节点），到从第二个点离开（返回它的父亲节点）的这一段路程，的确经过的深度最小的点就是‘最近公共祖先’这一个点！”

看着小Ho露出了惊讶的神情，小Hi满意的点了点头，道：“这就是一个很好的将树转换成数组来进行某些特殊算法的方法！而且你仔细看看就会发现转换出的数组的长度其实就是边数的2倍而已，也是O(n)的级别呢~”

“原来是这样！那这次我只需要简单的套用之前写的算法，很简单嘛！”小Ho笑道。

“那是自然，你也不看看之前我们积累了一个月呢，现在你要是还磨磨蹭蹭的，回国怎么向河蟹先生交代！”

“嘿嘿嘿……”

#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <cctype>
#include <list>
#include <cmath>
#include <bitset>
#include <queue>
#include <stack>
#include <sstream>
#include <functional>
#include <cassert>
using namespace std;

int RL(char _str[], int _maxlen = 1e8) {
	if (fgets(_str, _maxlen, stdin) == NULL) return -1;
	int i = 0;
	while (_str[i]) ++i;
	if (_str[i - 1] == '\n') _str[--i] = 0;
	return i;
}

inline int RI() {
	int temp;
	scanf("%d", &temp);
	return temp;
}

inline long long RLL() {
	long long temp;
	scanf("%I64d", &temp);
	return temp;
}

inline double RD() {
	double temp;
	scanf("%lf", &temp);
	return temp;
}

template <class T1, class T2>
inline void Max(T1 &a, T2 b) { if (b > a) a = b; }

template <class T1, class T2>
inline void Min(T1 &a, T2 b) { if (b < a) a = b; }

typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef long long LL;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-8;
const int mod = 100007;
const int maxn = 1e5 + 9;

int N, M, a[maxn*3], dp[20][maxn*3];
map<string, int> id;
string name[maxn];
vector<int> G[maxn];
int ix;

void ToArr(int x, int p) {
	a[ix++] = x;
	for (int i = 0; i < G[x].size(); ++i) {
		if (G[x][i] != p) {
			ToArr(G[x][i], x);
			a[ix++] = x;
		}
	}
}

void InitRMQ() {
	ToArr(1, 0);
	for (int i = 0; i < ix; ++i) dp[0][i] = a[i];
	for (int i = 1; 1 << i <= ix; ++i) {
		for (int j = 0; j + (1 << i) <= ix; ++j) {
			dp[i][j] = min(dp[i - 1][j], dp[i - 1][j + (1 << (i - 1))]);
		}
	}
}

int RMQ(int l, int r) {
	if (l > r) swap(l, r);
	int k = log(r - l + 1) / log(2);
	return min(dp[k][l], dp[k][r - (1 << k) + 1]);
}

int main() {
	//std::ios::sync_with_stdio(0);
	//std::cin.tie(0);
#ifdef NIGHT_13
	freopen("in.txt", "r", stdin);
	//freopen("myout.txt", "w", stdout);
#endif
	int CAS = 0;
	int _id = 0;
	scanf("%d", &N);
	while (N--) {
		char p1[100], p2[100];
		scanf("%s%s", p1, p2);
		int ida, idb;
		if (!(ida = id[p1])) { ida = id[p1] = ++_id; name[_id] = p1; }
		if (!(idb = id[p2])) { idb = id[p2] = ++_id; name[_id] = p2; }
		G[ida].push_back(idb);
		G[idb].push_back(ida);
	}
	InitRMQ();
	scanf("%d", &M);
	for (int i = 1; i <= M; ++i) {
		char p1[100], p2[100];
		scanf("%s%s", p1, p2);
		int pa = id[p1], pb = id[p2];
		int l = ix, r = ix;
		while (a[l] != pa) --l;
		while (a[r] != pb) --r;
		printf("%s\n", name[RMQ(l,r)].c_str());
	}
	return 0;
}


fushenliao
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
LCA (最近公共祖先) Tarjan & 倍增
01-03
LCA Tarjan： 实现原理 理解：离线算法，建好树后再查询，一次DFS 吧所有查询解决完。 时间复杂度：O(n+q)； n个点 q次询问 补一下：链式向前星，并查集 ，Tarjan 代码 #include #include #include #include #include using namespace std; const int MAXN = 5e5+ 10; int fa[MAXN], head[MAXN], head_ask[MAXN], cnt, cnt_ask, ans[MAXN]; bool vis[MAXN]; int n, m, s; struct Edge{
二叉树最近最近公共祖先
05-15
在二叉树中，最近公共祖先（最近共同祖先，LCA，Lowest Common Ancestor）是指两个节点在树中的最近的共同父节点。在某些应用场景，如文件系统或社交网络中，找到最近公共祖先具有重要意义。 针对给定的"二叉树最近...
快速求树中某个节点的k级祖先【树上倍增/LCA魔改】
nefu_ljw的博客
12-20 2609
题目描述 Time Limit: 12000 MS Memory Limit: 131072 K Description 你将得到一个有根树，其中根节点的位置是已知的。 其后将有多个询问，每个询问包括两个属性x和k，要求你找到x的第k级祖先，如果不存在，则输出“0”。 假设有一棵树形如下图： 其中，树的根节点为绿色点。 若x为红点，则其二级祖先是蓝色点，三级祖先是绿色点。 Input 本题为多组...
最近公共祖先1
烟雨流年
07-05 667
题目描述 有一棵无穷大的满二叉树，其结点按根结点一层一层地从左往右依次编号，根结点编号为1。现在有两个结点a，b。请设计一个算法，求出a和b点的最近公共祖先的编号。 给定两个int a,b。为给定结点的编号。请返回a和b的最近公共祖先的编号。注意这里结点本身也可认为是其祖先。 测试样例： 2，3 返回：1class LCA { public: int getLCA
POJ - 1330 Nearest Common Ancestors(LCA最近公共祖先 朴素算法&倍增法)
kuronekonano的博客
03-30 237
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 roo...
最近公共祖先 LCA 算法详解- 朴素、在线、离线
戴挽舟的博客
07-18 2795
最近公共祖先LCA 定义 最近公共祖先简称 LCA（Lowest Common Ancestor）。两个节点的最近公共祖先，就是这两个点的公共祖先里面，离根最远的那个。 例题 这里先举例具体题目，下面根据不同方法给出不用题解代码。 洛谷 【模板】最近公共祖先（LCA） 题目描述 如题，给定一棵有根多叉树，请求出指定两个点直接最近的公共祖先。 输入格式 第一行包含三个正整数 N,M,S 分别表示树的结点个数、询问的个数和树根结点的序号。 接下来 N-1 行每行包含两个正整数 x, y表示 x 结点和 y 结
我的OI技巧，送给广大信息学初学者
一生悬命
03-19 3445
我的OI技巧，送给广大信息学初学者即将告别我的NOIP了，一直想留下点什么给后来的OIers们，但是鉴于本人还是比较菜的，所以也只有指导指导那些初学者了。 书籍推荐：绿书+蓝书（青少年信息学奥林匹克竞赛培训教材 系列）、算法导论、粉书（全国青少年信息学奥林匹克联赛培训教材）、黑书（算法艺术 建议水平高的人看）、新编实用算法（建议水平高的人看） 题库推荐：Usaco（强烈推荐，很经典的题
算法基础 - 最近公共祖先（在线算法/离线算法）
累了就歇一会
05-19 1283
最近公共祖先最近公共祖先的问题已经在前面的博客有说过了。要看代码的，本篇博客写的是普通树的最近公共祖先，并不是二叉树，也许有时间我会写一下在线算法思想对树进行dfs（也就是先序遍历），在遍历过程中，记录下遍历的顺序，这里要注意的是，遍历要记录下所有路径，包括节点的第二次访问，或第三次访问。然后这样就是一个数组了。 0 / \ 1 2 /|\ \ 3 4
LCA（最近公共祖先）离线算法Tarjan
Baoli1008的专栏
07-21 926
转自ACer_FInd 点击打开链接 LCA（最近公共祖先）离线算法Tarjan+并查集 LCA问题:给出一棵有根树T，对于任意两个结点u,v求出LCA(T, u, v)，即离根最 远的结点x，使得x同时是u和v的祖先。     把LCA问题看成询问式的:给出一系列询问，程序应当对每一个询问尽快做出反应。 对于这类问题有两种解决方法;
LCA（最近公共祖先）离线算法Tarjan+并查集
weixin_30551947的博客
01-22 140
本文来自：http://www.cnblogs.com/Findxiaoxun/p/3428516.html 写得很好，一看就懂了。 在这里就复制了一份。 LCA问题: 给出一棵有根树T，对于任意两个结点u,v求出LCA(T,u,v)，即离根最远的结点x，使得x同时是u和v的祖先。 把LCA问题看成询问式的:给出一系列询问，程序应当对每一个询问尽快做出反应...
LCA.tar.zip_二叉树的最近公共祖先问题
最新发布
09-20
在计算机科学领域，二叉树的最近公共祖先（Lowest Common Ancestor，简称LCA）问题是一个经典的数据结构问题，特别是在图论和算法设计中。最近公共祖先指的是在一棵树中，两个节点的共同祖先中离叶子节点最远的一个...
最低公共祖先算法实现
03-24
最低公共祖先（Lowest Common Ancestor，简称LCA）算法是数据结构与算法中的一个重要概念，主要用于处理树形结构的问题，比如在二叉树、树状数组或图中找到两个节点的最近公共祖先。在本项目中，它通过C++语言实现，...
二叉排序树最近公共祖先
05-17
int found(Bstnode *p,int a, int b) //查找两个不同结点的最近公共祖先 { Bstnode *q; int i=0; if(a==p->key||b==p->key) return i; //如果两个结点中有一个是根结点 else while(p!=NULL){ //则表明它们没有...
基于堆优化的Prim，另附kruskal解法
Liao Fushen
05-21 1387
最小生成树的Prim算法也是贪心算法的一大经典应用。Prim算法的特点是时刻维护一棵树，算法不断加边，加的过程始终是一棵树。
ZSC 1155 ZQU_ACM 协会 (并查集入门)
Liao Fushen
02-25 1322
Description ACMer在ZQU已经有好几年的历史了，最近，他们想成立一个协会，叫ZQU_ICPC协会。我们都知道，在ZQU成立一个协会是需要很多手续的，而且还有一个人数上的条件，即必须满足一定的人数才可以得到学校的批准。 所以，现有的ACMer开始到处宣传，希望能够找到尽量多的人进入协会。 现在给出同学们的关系以及最开始的ACMer的号码。 请问他们的人数足够满足条件吗？Input
选课 树形DP 多叉树转二叉树
Liao Fushen
03-19 1217
选课&ndsp树形DP&ndsp多叉树转二叉树 题目描述 学校实行学分制。每门的必修课都有固定的学分，同时还必须获得相应的选修课程学分。学校开设了N门的选修课程，每个学生可选课程的数量M是给定的。学生选修了这M门课并考核通过就能获得相应的学分。 在选修课程中，有些课程可以直接选修，有些课程需要一定的基础知识，必须在选了其它的一些课程的基础上才能选修。例如《Frontpage》必须在选修了
二叉树 由中序遍历和前序遍历推后序遍历
Liao Fushen
02-06 826
根据后序遍历’=‘左子树的后序遍历’+‘右子树的后序遍历’+‘根节点递归求解即可 char pre[maxn], in[maxn], post[maxn]; void Post(char* _pre, char* _in, int _len, int _root) { if (_len <= 0) return; int i = 0; while (_in[i] != _pre[0])
HDU4825 Xor Sum(Trie树 + 贪心)
Liao Fushen
07-21 745
Xor Sum Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 132768/132768 K (Java/Others) Total Submission(s): 1265    Accepted Submission(s): 527 Problem Description Zeus 和 Prometheus
最近公共祖先LCA算法详解——C++实现
Tarjan算法是一种离线算法，它在一次遍历中处理所有查询，总时间复杂度为O(n+q)，其中n是树的节点数，q是查询数量。算法的核心思想是采用深度优先搜索（DFS）遍历树，并通过并查集进行节点的合并，以确定最近公共...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值