nyoj 349 poj 1094 Sorting It All Out

Sorting It All Out

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 34819		Accepted: 12210

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.

 

nyoj上面的数据较弱，在poj上过了才可以。

nyoj 349 ：http://acm.nyist.net/JudgeOnline/problem.php?pid=349

poj 1094： http://poj.org/problem?id=1094

该题题意明确，就是给定一组字母的大小关系判断他们是否能组成唯一的拓扑序列。是典型的拓扑排序，但输出格式上确有三种形式：

   1.该字母序列有序，并依次输出；

   2.该序列不能判断是否有序；

   3.该序列字母次序之间有矛盾，即有环存在。

     而这三种形式的判断是有顺序的：先判断是否有环（3），再判断是否有序（1），最后才能判断是否能得出结果（2）。注意：对于（2）必须遍历完整个图，而（1）和（3）一旦得出结果，对后面的输入就不用做处理了。

对于拓扑排序判断是否有环，就查找这个序列是否存在入度为零的节点，需要查找n次，每找到一个入度为零的节点，其相邻的节点的入度也会发生变化，所以要循环n次。

判断是否有序就简单了，如果同一时刻存在多个入度为零的节点，那么就有多个拓扑序列，不能确定了。

AC代码：

 

#include <iostream>

#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

int map[30][30], in_degree[30];

int qu[30];

int Topsort(int n)

{

    int temp[30], m, flag = 1, k, t = 1;

 

    for(int i = 1; i <= n; i++)

    {

        temp[i] = in_degree[i];

    }

    for(int i = 1; i <= n; i++) ///遍历n次  

    {

        m = 0;

        for(int j = 1; j <= n; j++)  ///遍历n个节点中入度为零的个数

        {

            if(temp[j]==0)

            {

                m++;

                k = j;

            }

        }

        if(m==0)  ///有环

            return 0;

        if(m > 1) ///拓扑序列不唯一

            flag = -1;

        qu[t++] = k;

        temp[k] = -1;

        for(int j = 1; j <= n; j++)

        {

            if(map[k][j]==1) ///如果从k到j有路 那么j的入度减一

                temp[j]--;

        }

    }

    return flag;

}

int main()

{

    int m, n,sign;

    char str[5];

    while(~scanf("%d%d",&n,&m))

    {

        if(n==0&&n==0)

            break;

        sign = 0;

        memset(map, 0, sizeof(map));

        memset(in_degree, 0, sizeof(in_degree));

        for(int i = 1; i <= m; i++)

        {

            scanf("%s",str);

            if(sign) continue; ///如果现有的关系足以找到结果 那么后面的输入不用再处理

            int x = str[0] - 'A' + 1;

            int y = str[2] - 'A' + 1;

            map[x][y] = 1;

            in_degree[y]++;

            int s = Topsort(n);

            if(s==0) ///有环

            {

                printf("Inconsistency found after %d relations.\n",i);

                sign = 1;

            }

            if(s==1)///有唯一的序列

            {

                printf("Sorted sequence determined after %d relations: ",i);

                for(int j = 1; j <= n; j++)

                {

                    printf("%c",qu[j] + 'A' - 1);

                }

                printf(".\n");

                sign = 1;

            }

        }

        if(!sign)///序列不确定

        {

            printf("Sorted sequence cannot be determined.\n");

        }

    }

    return 0;

}