hud 1811 Rank of Tetris(拓扑排序+并查集+STL)

Rank of Tetris

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3671    Accepted Submission(s): 1026


Problem Description
自从Lele开发了Rating系统,他的Tetris事业更是如虎添翼,不久他遍把这个游戏推向了全球。

为了更好的符合那些爱好者的喜好,Lele又想了一个新点子:他将制作一个全球Tetris高手排行榜,定时更新,名堂要比福布斯富豪榜还响。关于如何排名,这个不用说都知道是根据Rating从高到低来排,如果两个人具有相同的Rating,那就按这几个人的RP从高到低来排。

终于,Lele要开始行动了,对N个人进行排名。为了方便起见,每个人都已经被编号,分别从0到N-1,并且编号越大,RP就越高。
同时Lele从狗仔队里取得一些(M个)关于Rating的信息。这些信息可能有三种情况,分别是"A > B","A = B","A < B",分别表示A的Rating高于B,等于B,小于B。

现在Lele并不是让你来帮他制作这个高手榜,他只是想知道,根据这些信息是否能够确定出这个高手榜,是的话就输出"OK"。否则就请你判断出错的原因,到底是因为信息不完全(输出"UNCERTAIN"),还是因为这些信息中包含冲突(输出"CONFLICT")。
注意,如果信息中同时包含冲突且信息不完全,就输出"CONFLICT"。
 

Input
本题目包含多组测试,请处理到文件结束。
每组测试第一行包含两个整数N,M(0<=N<=10000,0<=M<=20000),分别表示要排名的人数以及得到的关系数。
接下来有M行,分别表示这些关系
 

Output
对于每组测试,在一行里按题目要求输出
 

Sample Input
   
   
   
   
3 3 0 > 1 1 < 2 0 > 2 4 4 1 = 2 1 > 3 2 > 0 0 > 1 3 3 1 > 0 1 > 2 2 < 1
 

Sample Output
   
   
   
   
OK CONFLICT UNCERTAIN
 

一道很好的拓扑排序题,因为有等号的缘故,所以加大了难度。

题目数据量比较大,肯定不能用邻接矩阵来储存关系,会超内存,所以果断选择用领接表,然后用了一下午的时间学习了STL里面的vector。一开始没有考虑到连等的情况,所以没有用到并查集去合并‘=’,而是纯手动的读到‘=’就让两个点的入度相等(这样做完全行不通,不光出现1 = 2 = 3的情况回出错,1  > 2, 2 = 3, 4 > 3 的时候也会WA)后来引入并查集去处理等号以后就超时,经过很长时间的优化终于踩点过了,所以说有时候必要的学习时应该的。下面给出一些容易错的数据(仅供参考):

4 3

1 > 0

1 = 2

3 > 2

OK

5 4

1 > 0

1 = 2

2 = 3

3 < 4

OK

7 6

1 > 0

1 = 2

2 = 3

2 > 5

3 > 6

4 > 3

NUCERTAIN

我的解题思路:在读如数据的同时, 碰到‘=’时用并查集进行处理,(这点不好,这样由于‘=’的出现次序,数据要被重复合并多次),然后用模拟的方式去判断(这里没有用到一些技巧很惭愧),因为名次时确定的话每次只会有一个点的入度为0,如果同时有两个点的入度为0,说明名次不能被确定,如果有向图中出现环,说明冲突。(这里要注意的是条件不足时不能直接停止判断,因为后面还有可能出现错误)

#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;

#define N 10005
#define INT vector<int>::iterator

int n, m, cnt, all, bir[N];
int rec[N * 2][2], vis[N], num[N];
vector<int> G[N];

void handle(int a, int b){
	if (a == b)
		return;
	for (INT i = G[a].begin(); i != G[a].end(); i++)
			G[b].push_back(*i);
	num[a] = b;
	all++;
}

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

int topo(int k, int sum){
	vis[k] = 1;
	int ok = 0;
	for (INT i = G[k].begin(); i != G[k].end(); i++){
		int a = find(*i);
		if (vis[a])		return -1;
		ok = topo(a, sum + 1);
		if (ok)		return ok;
	}
	if (sum + all == n)		return 1;
	vis[k] = 0;
	return 0;
}

int main(){
	int a, b;
	char c;
	while (scanf("%d%d", &n, &m) != EOF){
		// Init.
		all = cnt = 0;
		memset(rec, 0, sizeof(rec));
		memset(bir, 0, sizeof(bir));
		for (int i = 0; i < n; i++)
			G[num[i] = i].clear();

		// Read.
		for (int i = 0; i < m; i++){
			scanf("%d %c %d", &a, &c, &b);
			if (c == '<')
				G[b].push_back(a);
			else if (c == '>')
				G[a].push_back(b);
			else{
				rec[cnt][0] = a;
				rec[cnt][1] = b;
				cnt++;
			}
		}

		// Handle.
		for (int i = 0; i < cnt; i++)
			handle(find(rec[i][0]), find(rec[i][1]));

		// Judge.
		int ok = 0;
		for (int i = 0; i < n; i++){
			a = find(i);
			if (bir[a])		continue;
			memset(vis, 0, sizeof(vis));
			ok = topo(a, 1);
			if (ok)			break;
			bir[a] = 1;
		}

		if (ok == 1)
			printf("OK\n");
		else if (ok == -1)
			printf("CONFLICT\n");
		else
			printf("UNCERTAIN\n");
	}
	return 0;}
这是我研究了下别人的代码,然后结合自己代码优点写的,主要改了数据读入的地方,是在读取到‘=’时,先用并查集将两点合并(注意已经相等的点处理,对后面判断回有所影响),在所有数据都读取完毕后,在对‘<' 和‘>'进行处理(这里处理时直接找到根结点,在根节点处操作)。 还有在拓扑排序的实现上引用了队列进行模拟,起先处理时有记录每个点的入度个数,当入度为0时入队,如果出现过队列大小大于1的情况,说明排序不唯一,如果没有点入度为0 时,被确定排序的点不足n个时,为冲突。

#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>
using namespace std;
#define N 10005

int n, m, cnt;
int X[2 * N], Y[2 * N], far[N], son[N];
char C[2 * N];
vector<int> G[N];

int get(int x){
	return x != far[x]?far[x] = get(far[x]):x;
}
bool Union(int a, int b){
	if (a == b)
		return false;
	far[a] = b;
	return true;
}

int main(){
	while (scanf("%d%d", &n, &m) != EOF){
		// Init.
		memset(son, 0, sizeof(son));
		for (int i = 0; i < n; ++i)
			G[far[i] = i].clear();
		cnt = n;
        
		// Read.
		for (int i = 0; i < m; i++){
			scanf("%d %c %d", &X[i], &C[i], &Y[i]);
			if (C[i] == '=' && Union(get(X[i]), get(Y[i])))
				cnt--;
		}

		// Handle.
		for (int i = 0; i < m; i++){
			int a = get(X[i]), b = get(Y[i]);
			if (C[i] == '<'){
				G[b].push_back(a);
				son[a]++;
			}
			else if (C[i] == '>'){
				G[a].push_back(b);
				son[b]++;
			}
		}

		queue<int> que;
		int ok = 0;
		for (int i = 0; i < n; i++)
			if (!son[i] && i == get(i))
				que.push(i);
	
		while (!que.empty()){
			if (que.size() > 1)
				ok = 1;
			int t = que.front();
			que.pop();
			cnt--;
			for (int i = 0; i < G[t].size(); i++)
				if (--son[G[t][i]] == 0)
					que.push(G[t][i]);
		}

		if (cnt > 0)
			printf("CONFLICT\n");
		else if (ok)
			printf("UNCERTAIN\n");
		else
			printf("OK\n");
	}
	return 0;}

你可能感兴趣的:(hud 1811 Rank of Tetris(拓扑排序+并查集+STL))