ACM: poj 1094 Sorting It All Out - 拓扑排序
poj 1094 Sorting It All Out
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.
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;
}
