ACM: poj 1094 Sorting It All Out - 拓扑排序

poj 1094 Sorting It All Out

Time Limit:1000MS     Memory Limit:10000KB     64bit IO Format:%lld & %llu

Description

An ascending sorted sequence of distinct values is one in which some form of a less-than operator is used to order the elements from smallest to largest. For example, the sorted sequence A, B, C, D implies that A < B, B < C and C < D. in this problem, we will give you a set of relations of the form A < B and ask you to determine whether a sorted order has been specified or not.

Input

Input consists of multiple problem instances. Each instance starts with a line containing two positive integers n and m. the first value indicated the number of objects to sort, where 2 <= n <= 26. The objects to be sorted will be the first n characters of the uppercase alphabet. The second value m indicates the number of relations of the form A < B which will be given in this problem instance. Next will be m lines, each containing one such relation consisting of three characters: an uppercase letter, the character "<" and a second uppercase letter. No letter will be outside the range of the first n letters of the alphabet. Values of n = m = 0 indicate end of input.

Output

For each problem instance, output consists of one line. This line should be one of the following three:

Sorted sequence determined after xxx relations: yyy...y. 
Sorted sequence cannot be determined. 
Inconsistency found after xxx relations.

where xxx is the number of relations processed at the time either a sorted sequence is determined or an inconsistency is found, whichever comes first, and yyy...y is the sorted, ascending sequence.

Sample Input

4 6
A<B
A<C
B<C
C<D
B<D
A<B
3 2
A<B
B<A
26 1
A<Z
0 0

Sample Output

Sorted sequence determined after 4 relations: ABCD.
Inconsistency found after 2 relations.
Sorted sequence cannot be determined.

/*/
给出字母个数和提示次数，排出ABCD......的大小

按照格式[c1]<[c2]输入，请判断是否能够按照输入严格排序，如果可以就输出在第多少次输入后就已经成功排序，并且输出排序的队列 ；
【Sorted sequence determined after xxx relations: yyy...y.】

如果输完后不能够按照大小严格排序，就输出不可以成功排序【Sorted sequence cannot be determined. 】

如果在输入后出现了A>B,B<A的矛盾输出矛盾出现的次数【Inconsistency found after xxx relations. 】

要注意中途记录输入的次数，或者按照输入一次判断一次，随时对输入进行终止，但是要注意后面继续输入的吸收。

思路，用拓扑排序进行解题，每组进行输入如果排序过程中严格递增即入度为0的点只有一个，就正常排序。

如果出现入度为0的点有多个则就是说明有的点没有严格排序，要再次进行排序，直到输入结束后还是有多个入度==0的点，就说明不能够成功排序。

 如果出现某次找不到入度为0的点，说明已经成环即出现矛盾。可以结束这次排序了。

ＡＣ代码：
/*/

#include"algorithm"
#include"iostream"
#include"cstring"
#include"cstdlib"
#include"string"
#include"cstdio"
#include"vector"
#include"cmath"
#include"queue"
using namespace std;
#define memset(x,y) memset(x,y,sizeof(x))
#define memcpy(x,y) memcpy(x,y,sizeof(x))
#define MX 30
int cnt;
int map[MX][MX]; //邻接矩阵
int indegree[MX]; //入度
int flag;

queue<int >q;

int toposort(int map[MX][MX],int n) {
	int mp[MX][MX];
	memcpy(mp,map);
	memset(indegree,0);
	for(int j=0; j<n; j++) {
		for(int k=0; k<n; k++) {
			if(mp[j][k]==1) {
				indegree[k]++;
			}
		}
	}
	flag=-1;
	queue<int> qq;
	for (int i=0; i<n;) {
		int count=0;
		for (int j=0; j<n; j++) {
			if (indegree[j]==0) count++;//记录入度为0的点的数量
		}
		if(!count)return 2;//有环。
		if(count>1) flag=1;//如果入度为0的点大于一个无法判断他的唯一排序性
		for(int j=0; j<n; j++) {
			if(!indegree[j]) {
				++i;
				qq.push(j);
				for (int k=0; k<n; k++) {
					if (mp[j][k]) {
						indegree[k]--; //减少入度
						mp[j][k]=0; //删边
					}
				}
				indegree[j]=-1;
				break;//一次循环消除一个点
			}
		}
	}
	if(flag!=1) { //判断是否需要维护队列 是否进行了消边操作 如果flag！=1则说明无法再进行消边操作，即已经全部排序好了。
		q=qq;
		return 0; //
	} else return 1;//还未结束
}

int main() {
	char s[10];
	memset(s,0) ;
	int n,m,st,ed;
//	freopen("in.txt", "r", stdin);
	while(~scanf("%d %d",&n,&m)) {
		if(!m&&!n)break;
		cnt=0;
		flag=-1;
		memset(map,0);
		for(int i=1; i<=m; i++) {
			scanf("%s",s);
			st=(int)s[0]-'A';
			ed=(int)s[2]-'A';
			map[st][ed]=1;
			if (flag==0||flag==2) continue;//如果已经成环或者已经无法再操作了就跳过操作 吸收后面的输入
			else flag=toposort(map,n);
			if(flag==0) {
				printf("Sorted sequence determined after %d relations: ",i);
				while (!q.empty()) {
					int ch=q.front();
					q.pop();
					printf("%c",ch+'A');
				}
				puts(".");
			} else if (flag==2) {
				printf("Inconsistency found after %d relations.\n",i);
			}
		}

		if (flag==1)puts("Sorted sequence cannot be determined.");
	}
	return 0;
}