poj 1094 / zoj 1060 Sorting It All Out

Sorting It All Out

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 26876		Accepted: 9271

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.

Source

East Central North America 2001

[Submit]   [Go Back]   [Status]   [Discuss]

解题思路：这题是一个拓扑排序问题，不过过程比较复杂，要处理的情况也比较多！首先题目条件和要求要很清楚，这样分析问题思路就会清晰！

解题代码：

 #include <stdio.h>
 #include <string.h>
 #include <iostream>
 using namespace std;
 struct Node{            //与之相连的节点结构体
     int to;
     struct Node *next;
 };
 Node *Link[]; //链表保存连接关系
 Node *tm_node;
 bool vis[];
 int count[], tm_count[]; //保存节点入度数据，前者为备份数据，后者为运算数据
 int n, m, num;
 char deal[];
 const int A = 'A';
 int result[], pos; //保存结果 

 int TopSort(){
     int i, j, cnt;
     bool flag = false;
     pos = cnt = ;// cnt为入度为0的节点数，pos为保存结果的下标
     j = -; //入度为0的字母
     for (i = ; i < n; i ++) //寻找入度为0的位置
         if(tm_count[i] ==  && vis[i]){
             cnt ++;
             j = i;
         }
     while (~j){
         if(cnt > ) //如果cnt > 1 则表示有多个入度为0的节点，也就是说可能无法排序
             flag = true; //不直接return是因为还有可能图中有环，导致数据矛盾
         for (tm_node = Link[j]; tm_node != NULL; tm_node = tm_node ->next)
             tm_count[tm_node ->to] --;
         result[pos ++] = j;
         tm_count[j] --;
         j = -;
         cnt = ;
         for (i = ; i < n; i ++)
             if(tm_count[i] ==  && vis[i]){
                 cnt ++;
                 j = i;
             }
     }
     if(!flag && pos != num) // 图中有环，数据矛盾
         return -;
     if(!flag && pos == num) //图中为一个有序序列，是否是最终结果还需进一步判断
         return ;
     if(flag && pos == num)  //图中有多个有序序列，还需进一步判断
         return ;
     if(flag && pos != num)  //图中有环，数据矛盾
         return -;
 }

 void init(){
     num = ;
     memset(vis, , sizeof(vis));
     memset(Link, , sizeof(Link));
     memset(count, , sizeof(count));
     memset(tm_count, , sizeof(tm_count));
 }

 void input(){
     int d1, d2;
     scanf("%s", deal);
     d1 = deal[] - A;
     d2 = deal[] - A;
     tm_node = new Node;
     tm_node ->next = NULL;
     tm_node ->to = d2;
     count[d2] ++;
     if(Link[d1] == NULL)
         Link[d1] = tm_node;
     else{
         tm_node ->next = Link[d1];
         Link[d1] = tm_node;
     }
     if(vis[d1] == ){
         num ++;
         vis[d1] = true;
     }
     if(vis[d2] == ){
         num ++;
         vis[d2] = true;
     }
 }

 int main(){
     int i, j;
     int value;
     bool had_ans;
     while(~scanf("%d%d", &n, &m) && (n && m)){
         init(); //初始化
         had_ans = false; //是否已经得出结果
         for(i = ; i <= m; i ++){
             if(had_ans){  //如果已有结果，则无须处理后续数据
                 scanf("%s", deal);
                 continue;
             }
             input(); //数据处理
             for(j = ; j < n; j ++)
                 tm_count[j] = count[j];
             value = TopSort(); //拓扑排序
             if (value == -){
                 printf ("Inconsistency found after %d relations.\n", i);
                 had_ans = true;
             }
             else if(value ==  && num == n){ //数据量以满足要求，且能排序
                 printf ("Sorted sequence determined after %d relations: ", i);
                     for (j = ; j < n; j ++)
                         printf ("%c", result[j] + A);
                 printf(".\n");
                 had_ans = true;
             }
         }
         if (value ==  || (value ==  && n != num)) // 无法排序
             printf("Sorted sequence cannot be determined.\n");
     }
     return ;
 }