【拓扑排序】poj 1094_Sorting It All Out_201408081725

Sorting It All Out

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 27632		Accepted: 9572

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

题意：给你一些大写字母的大小关系，根据给的关系，问你在第几个关系的时候（1、能把这n个字母排成一个序列；2、当上下给的关系自相矛盾；3、能排成的序列不唯一）

提示：拓扑排序

思路：给一组关系进行一次拓扑排序（经过拓扑排序可以判断是否有环，序列是否唯一）

重难点：

所有可能的情况罗列:
 
（独家经验原创，重中之重！可以说没有这些，这题就无法AC！）
一、当输入的字母全部都在前n个大写字母范围内时：
（1）       最终的图 可以排序：
         在输入结束前如果能得到最终的图（就是用这n个字母作为顶点，一个都不能少）；而且最终得到的图  无环；
          只有唯一一个 无前驱（即入度为0）的结点，但允许其子图有多个无前驱的结点。

    !!!!   在这步输出排序后，不再对后续输入进行操作
（2）输出矛盾
      在输入结束前如果最终图的子图有环
    !!!!   在这步输出矛盾后，不再对后续输入进行操作
（3）输出无法确认排序
     这种情况必须全部关系输入后才能确定，其中又有2种可能
    ①最终图的字母一个不缺，但是有多个  无前驱结点
    ②输入结束了，但最终的图仍然字母不全，与 无前驱结点 的多少无关
二、当输入的字母含有 非前n个大写字母 的字母时（超出界限）：
（1）       输出矛盾
  输入过程中检查输入的字母（结点），若 前n个大写字母 全部出现，则在最后一个大写字母出现的那一步 输出矛盾
（2）       输出无法确认排序
  最后一步输入后，前n个大写字母 仍然未全部出现，则输出 无法确认排序
 
PS：在使用“无前驱结点”算法时必须要注意，在“矛盾优先”的规律下，必须考虑一种特殊情况，就是多个无前驱结点与环共存时的情况，即输入过程中子图都是有 多个无前驱结点，最后一步输入后出现了环，根据算法的特征，很容易输出“不能确认排序”，这是错的，必须适当修改算法，输出“矛盾”。
例如：
6 6
A<F
B<D
C<E
F<D
D<E
E<F
输出矛盾

附上AC代码：

#include <cstdio>
#include <cstring>
#include <stack>

using namespace std;

const int N = 30;

int map[N][N],degree[N],list[N];
int n,m;

int top_sort()
{
    int i,j,k,t;
    int d[N];
    stack<int > s;
    memset(list,0,sizeof(list)); 
    memcpy(d,degree,sizeof(degree));//将入度数组拷贝，防止影响下次top_sort
    for(i=0;i<n;i++)
    {
        if(!d[i])
        s.push(i);
    } 
    int flag = 0;
    k = 0;
    while(!s.empty())
    {
        if(s.size()>1)//判断序列是否唯一 
            flag = 1;
        t = s.top();
        s.pop();
        list[k++]=t;//记录出栈数字，即序列 
        for(i=0;i<n;i++)//更新入度 
        {
            if(map[t][i])
            {
                d[i]--;
                if(d[i]==0)
                    s.push(i);//入读为0的进栈 
            }
        }
    }
    if(k!=n)//不能进行拓扑排序，即有环 
        return 1;
    else if(flag==1)//序列不唯一，有多种排序方式 
        return 2;
    return 0;//序列确定 
       
}

int main()
{
    while(scanf("%d%d%*c",&n,&m),n||m)
    {
        int i,j,k,t1,t2,ans=0,flag=0;
        char a,b;
        memset(map,0,sizeof(map));
        memset(degree,0,sizeof(degree));
        for(i=0;i<m;i++)
        {
            scanf("%c<%c",&a,&b);
            getchar();
            //printf("%c,%c\n",a,b);
            if(!flag)//标记是否有输出 
            {
                t1 = a-'A';t2 = b - 'A';
                ans = 0;
                if(t1<n&&t2<n)
                {
                    if(map[t2][t1])
                    {
                        printf("Inconsistency found after %d relations.\n",i+1);
                        flag = 1;
                    } 
                    else
                    {
                        map[t1][t2]=1;
                        degree[t2]++;
                        ans = top_sort();
                        if(ans==0)
                        {
                            printf("Sorted sequence determined after %d relations: ",i+1);
                            for(k=0;k<n;k++)
                            printf("%c",list[k]+'A');
                            printf(".\n");
                            flag = 1;
                        } 
                        else if(ans==1)
                        {
                            printf("Inconsistency found after %d relations.\n",i+1);
                            flag = 1;
                        }
                    }
                }
                else
                {
                    printf("Inconsistency found after %d relations.\n",i+1);
                    flag = 1;
                }
            }
        }
        if(!flag)
        printf("Sorted sequence cannot be determined.\n");
    }
    return 0;
}

体会：拓扑排序的一个复杂一点的应用吧，拓扑排序的时候用 stack还是比较方便的，比用数组记录好很多，STL很方便，要慢慢学着使用。