题解报告：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.
解题思路：拓扑排序裸题。做法：边读边进行拓扑排序，如果最后拓扑的个数小于n，说明图中有环，返回0，输出此时的位置i和对应的信息，下次直接跳过字符串的操作即可；如果返回值为1，说明拓扑次序唯一，直接输出对应信息和拓扑序列即可，同样下次直接跳过对字符串的操作；如果前两者都没有发生，即某次队列中顶点的入度数为0的个数不止一个，说明拓扑次序是不唯一的，输出对应的结果即可。
AC代码：

 #include<iostream>
 #include<vector>
 #include<queue>
 #include<string.h>
 #include<map>
 #include<cstdio>
 using namespace std;
 const int maxn=;
 int n,m,out[maxn],InDeg[maxn];char cs[];
 vector<int> vec[maxn];
 queue<int> que;
 int topsort(){//flag:-1次序不确定；1：次序唯一
     while(!que.empty())que.pop();//清空
     int cnt=,flag=,in[maxn];
     for(int i=;i<n;++i)in[i]=InDeg[i];//拷贝每个节点的入度数
     for(int i=;i<n;++i)
         if(!in[i])que.push(i);//先将入度为0的进队
     while(!que.empty()){
         if(que.size()>)flag=-;//次序不确定
         int now=que.front();out[cnt++]=now;que.pop();
         for(size_t i=;i<vec[now].size();++i)
             if(--in[vec[now][i]]==)que.push(vec[now][i]);
     }
     if(cnt!=n)return ;//成环
     return flag;
 }
 int main(){
     while(cin>>n>>m&&(n+m)){
         getchar();
         memset(InDeg,,sizeof(InDeg));
         for(int i=;i<n;++i)vec[i].clear();//全部清空
         int sign=;
         for(int i=;i<=m;++i){
             cin>>cs;
             if(sign)continue;//跳过下面的操作，表示结论已出
             int f1=cs[]-'A',f2=cs[]-'A';
             vec[f1].push_back(f2);
             InDeg[f2]++;
             int k=topsort();
             if(k==){//成环
                 printf("Inconsistency found after %d relations.\n",i);
                 sign=;//同时标记为1
             }
             if(k==){//有序
                 printf("Sorted sequence determined after %d relations: ",i);
                 for(int j=;j<n;++j)printf("%c",out[j]+'A');
                 printf(".\n");
                 sign=;
             }
         }
         if(!sign)printf("Sorted sequence cannot be determined.\n");//最后才确定次序是否唯一
     }
     return ;
 }