topSort

Sorting It All Out（poj1094）

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 30187		Accepted: 10442

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. 在第x个关系中可以唯一的确定排序，并输出。  

                2. 在第x个关系中发现了有回环（Inconsisitency矛盾）  

                3.全部关系都没有发现上面两种情况，输出第3种.  

要求对于给定的m个关系，一个个的读进去，每读进去一次就要进行一次拓扑排序，如果发现情况1和情况2，那么就不用再考虑后面的那些关系了，但是还要继续读完后面的关系（但不处理）。如果读完了所有关系，还没有出现情况1和情况2，那么就输出情况3.

拓扑排序实现方法一（for循环）：

 

 1 #include <iostream>
 2 #include <cstring>
 3 #include <string>
 4 #include <fstream>
 5 using namespace std;
 6 
 7 int grap[27][27];
 8 int indeg[26],temp[26];
 9 int n,m;
10 char seq[26];
11 
12 int topSort()
13 {
14     int flag = 1;
15     memcpy(temp,indeg,sizeof(indeg));
16     memset(seq, '\0',sizeof(seq));
17     for(int i = 0; i < n; i++)
18     {
19         int times = 0,loc;
20         for(int j = 0; j < n; j++)
21         {
22             if(temp[j] == 0)     //处理重边的情况，建图时要格外注意！
23             {
24                 times++;
25                 loc = j;
26             }
27         }
28         if(times > 1) flag = -1;
29         if(times == 0) return 0;
30         temp[loc]--;
31         seq[i] = 'A'+ loc;
32         for(int k = 0; k < n; k++)
33         {
34             if(grap[loc][k])
35             {
36                 temp[k]--;
37             }
38         }
39     }
40     return flag;
41 }
42 
43 int main()
44 {
45     while(cin >> n >> m)
46     {
47         if(n == 0 && m == 0)
48             break;
49             
50         memset(grap,0,sizeof(grap));
51         memset(indeg,0,sizeof(indeg));
52         bool ok = false;
53 
54         for(int i = 0; i < m; i++)
55         {
56             string ss;
57             cin >> ss;
58             if(ok) continue;
59             int row,col;
60             row = ss[0] - 65;
61             col = ss[2] - 65;
62             if(grap[row][col] == 0)
63             {
64                 grap[row][col] = 1;
65                 indeg[col]++;
66             }
67 
68             int flag = topSort();
69             if(flag==1)
70             {
71                 ok = true;
72                 cout << "Sorted sequence determined after " << i+1 << " relations: " << seq << "."<<endl;
73             }
74             else if(flag==0)
75             {
76                 ok = true;
77                 cout << "Inconsistency found after " << i+1 << " relations." << endl;
78             }
79         }
80         
81         if(!ok)
82         {
83             cout << "Sorted sequence cannot be determined." << endl;
84         }
85     }
86 
87     return 0;
88 }

View Code

 

拓扑排序实现方法二（借助队列或栈）：

 1 #include <iostream>
 2 #include <cstring>
 3 #include <string>
 4 #include <fstream>
 5 #include <queue>
 6 #include <stack>
 7 using namespace std;
 8 
 9 int grap[27][27];
10 int indeg[26];
11 int n,m;
12 char seq[26];
13 
14 //借助队列实现拓扑排序，改成栈也一样
15 int topSort()
16 {
17     int in[26];
18     memcpy(in,indeg,sizeof(indeg));
19     memset(seq, '\0',sizeof(seq));
20     queue<int> s;
21 
22     for(int i=0; i<n; i++)
23     {
24         if(in[i] == 0)
25             s.push(i);
26     }
27 
28     int flag=1;
29     int t,j=0;
30     while(!s.empty())
31     {
32         if(s.size()>1)
33             flag=-1;      //有多种排序方式，不能唯一确定
34         t=s.front();
35         s.pop();
36         seq[j++] = t + 65;
37         for(int i=0; i<n; i++)
38         {
39             if(grap[t][i])
40             {
41                 if(--in[i]==0)
42                     s.push(i);
43             }
44         }
45 
46     }
47 
48     if(j != n) return 0;  //存在环
49     else return flag;
50 }
51 
52 int main()
53 {
54     while(cin >> n >> m)
55     {
56         if(n == 0 && m == 0)
57             break;
58 
59         memset(grap,0,sizeof(grap));
60         memset(indeg,0,sizeof(indeg));
61         bool ok = false;
62 
63         for(int i = 0; i < m; i++)
64         {
65             string ss;
66             cin >> ss;
67             if(ok) continue;
68             int row,col;
69             row = ss[0] - 65;
70             col = ss[2] - 65;
71             if(grap[row][col] == 0)
72             {
73                 grap[row][col] = 1;
74                 indeg[col]++;
75             }
76 
77             int flag = topSort();
78             if(flag==1)
79             {
80                 ok = true;
81                 cout << "Sorted sequence determined after " << i+1 << " relations: " << seq << "."<<endl;
82             }
83             else if(flag==0)
84             {
85                 ok = true;
86                 cout << "Inconsistency found after " << i+1 << " relations." << endl;
87             }
88         }
89 
90         if(!ok)
91         {
92             cout << "Sorted sequence cannot be determined." << endl;
93         }
94     }
95 
96     return 0;
97 }

View Code