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.

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.

题意：给一些大写字母的偏序关系。判断是否存在唯一的关系，或者他们的关系是矛盾的,即造成了回路，或者到最后不能确定他们的关系。

用拓扑排序：

1.拓扑排序可以用栈来实现，每次入栈的是入度为0的节点。

1.拓扑排序的结果一般分为三种情况：1、可以判断 2、有环出现了矛盾 3、条件不足，不能判断.

2.这道题不仅需要判断这三种情况，而且还要判断在处理第几个关系时出现前两种情况，对于本道题来说三种情况是有优先级的。前两种情况是平等的谁先出现先输出谁的相应结果，对于第三种情况是在前两种情况下都没有的前提下输出相应结果的.

 #include <iostream>
 #include <cstdio>
 #include <stack>
 #include <cstring>
 using namespace std;
 const int maxn=;
 int n,m;
 int pb[maxn][maxn],rd[maxn],list[maxn];
 int toposort()
 {
     int i,j=;
     int in[maxn];
     memcpy(in,rd,sizeof(rd)); //复制入度数组，以防改变原数组
     stack <int> s;
     for(i=; i<n; i++) //入度为0的入栈
     {
         if(!in[i])
             s.push(i);
     }
     bool flag=false;
     while(!s.empty())
     {
         if(s.size()>)
             flag=true;
         int t=s.top(); // 记录出栈数字
         s.pop();
         list[j++]=t;
         for(i=; i<n; i++)
         {
             if(pb[t][i])
             {
                 in[i]--; //入度减一
                 if(!in[i])
                     s.push(i); //入度为0的继续入栈
             }
         }
     }
     if(j!=n) //存在回路
         return ;
     else if(flag) //有多重排序方式
         return ;
     return ;
 }
 int main()
 {
     while(cin>>n>>m,n||m)
     {
         memset(pb,,sizeof(pb));
         memset(rd,,sizeof(rd));
         char a,b;
         int frist,scend;
         frist=scend=;
         for(int i=; i<=m; i++)
         {
             getchar();
             scanf("%c<%c",&a,&b);
             if(!frist && !scend)
             {
                 if(pb[b-'A'][a-'A']==) //存在反向边
                 {
                     scend=;
                     printf("Inconsistency found after %d relations.\n",i);
                     continue;
                 }
                 if(!pb[a-'A'][b-'A'])
                 {
                     pb[a-'A'][b-'A']=;
                     rd[b-'A']++;
                 }
                 int res=toposort();  //进行拓扑排序
                 if(res==) //序列能够唯一被确定
                 {
                     printf("Sorted sequence determined after %d relations: ",i);
                     for(int j=; j<n; j++)
                         printf("%c",list[j]+'A');
                     printf(".\n");
                     frist=;
                 }
                 else if(res==) //存在回路
                 {
                     scend=;
                     printf("Inconsistency found after %d relations.\n",i);
                 }
             }

         }
         if(!frist&&!scend) //即不能唯一约定，又不构成回路
             printf("Sorted sequence cannot be determined.\n");
     }
     return ;
 }