AOJ 2170 暴力 / 并查集

最新推荐文章于 2021-08-05 23:21:13 发布

原创最新推荐文章于 2021-08-05 23:21:13 发布 · 234 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

基本算法同时被 2 个专栏收录

252 篇文章

订阅专栏

数据结构

203 篇文章

订阅专栏

本文详细解析了AOJ2170问题的两种解决策略：暴力搜索与并查集算法。通过对比不同方法的实现细节，包括路径压缩优化，展示了在树形结构中查找已标记节点的效率差异。

题意

传送门 AOJ 2170

暴力

保存标记，直接向父节点搜索。最坏情况树退化成链，复杂度会爆。

#include <cstdio>
#include <stdlib.h>
#include <cstring>
#include <iostream>
#include <algorithm>
#define min(a,b)    (((a) < (b)) ? (a) : (b))
#define max(a,b)    (((a) > (b)) ? (a) : (b))
#define abs(x)    ((x) < 0 ? -(x) : (x))
#define INF 0x3f3f3f3f
#define delta 0.85
#define eps 1e-3
#define PI 3.14159265358979323846
#define MAX_N 100005
using namespace std;
typedef long long ll;
int N, Q;
int tree[MAX_N];
bool mark[MAX_N];

int main(){
	while(~scanf("%d%d", &N, &Q) && N){
		memset(mark, 0, sizeof(bool) * (N + 1));
		tree[1] = 1;
		mark[1] = 1;
		for(int i = 2; i <= N; i++) scanf("%d", tree + i);
		ll sum = 0;
		for(int i = 0; i < Q; i++){
			int x;
			char c;
			scanf(" %c%d", &c, &x);
			if(c == 'M'){
				mark[x] = 1;
			}
			else{
				while(!mark[x]) x = tree[x];
				sum += x;
			}
		}
		printf("%lld\n", sum);
	}
	return 0;
}

并查集版本一

如果不进行路径压缩，并查集其实和暴力差不多，只是这里用并查集的方法标记节点，即 parent[x] = x，每次 find() 递归到最近父节点即返回。

#include <cstdio>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#define min(a,b)    (((a) < (b)) ? (a) : (b))
#define max(a,b)    (((a) > (b)) ? (a) : (b))
#define abs(x)    ((x) < 0 ? -(x) : (x))
#define INF 0x3f3f3f3f
#define delta 0.85
#define eps 1e-3
#define PI 3.14159265358979323846
#define MAX_N 100005
using namespace std;
typedef long long ll;
int N, Q;
int par[MAX_N];

int find(int x){
	return x == par[x] ? x : find(par[x]);
}

int main(){
	while(~scanf("%d%d", &N, &Q) && N){
		par[1] = 1;
		for(int i = 2; i <= N; i++) scanf("%d", par + i);
		ll sum = 0;
		for(int i = 0; i < Q; i++){
			int x;
			char c;
			scanf(" %c%d", &c, &x);
			if(c == 'M'){
				par[x] = x;
			}
			else{
				sum += find(x);
			}
		}
		printf("%lld\n", sum);
	}
	return 0;
}

并查集版本二

路径压缩的问题在于，如何判断节点可压缩。看到一个不错的方法，即保存标记以及查询的时间戳，并逆时间顺序查询。若当前查询节点被标记的时间点早于查询的时间点，则判为搜索到最邻近标记父节点；反之，之后的查询时间点小于当前查询时间点，必然也小于当前查询节点的时间戳，即该节点在其后查询中都不可能被标记，可被压缩处理。

#include <cstdio>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#define min(a,b)    (((a) < (b)) ? (a) : (b))
#define max(a,b)    (((a) > (b)) ? (a) : (b))
#define abs(x)    ((x) < 0 ? -(x) : (x))
#define INF 0x3f3f3f3f
#define delta 0.85
#define eps 1e-3
#define PI 3.14159265358979323846
#define MAX_N 100005
using namespace std;
typedef long long ll;
int N, Q;
int par[MAX_N], mark[MAX_N];
int qt[MAX_N], qv[MAX_N];

int find(int t, int x){
	return mark[x] < t ? x : par[x] = find(t, par[x]);
}

int main(){
	while(~scanf("%d%d", &N, &Q) && N){
		for(int i = 2; i <= N; i++){
			scanf("%d", par + i);
			mark[i] = INF;
		}
		int cnt = 0;
		for(int i = 1; i <= Q; i++){
			int x;
			char c;
			scanf(" %c%d", &c, &x);
			if(c == 'M'){
				mark[x] = min(mark[x], i);
			}
			else{
				qt[cnt] = i, qv[cnt] = x;
				++cnt;
			}
		}
		ll sum = 0;
		for(int i = cnt - 1; i >=0 ; i--){
			sum += find(qt[i], qv[i]);
		}
		printf("%lld\n", sum);
	}
	return 0;
}