【POJ】poj 1094（拓扑排序）

 

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.

 

题目大意：给出一些字母的偏序，让你判断是否有矛盾，是否有多种情况；如果情况唯一输出结果；

 

分析：简单的图论问题，首先建立二维数组；存图（图不大，可以用二维数组储存），每次输入一个条件，将条件加入之后进行判断，如果满足，或者出现矛盾的话就输出，但是继续吧文件读完；在最后判断有没有满足条件，或者出现矛盾，没有的话就输出不能确定；

代码：

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<stack>
using namespace std;

int ins[30],injudge[30],way[30];
int point,judge,where;
int pic[30][30];///存图
int judges()
{
    memcpy(injudge,ins,sizeof(ins));///将出入度复制过来；
    stack<int> s;
    for ( int i = 0; i < point; i++)
    {
        if ( injudge[i] == 0)
            s.push(i);///入度为0，就可以取下来为第一个；入栈；
    }
    int num = 0; int flag = 0;
    while ( !s.empty())
    {
        if ( s.size() > 1){flag = true;}///如果有两个入度0 的点那么就不能确定路线
        int temp = s.top(); s.pop();
        way[num++] = temp;///将入度为1 的值计入路线中
        for ( int i = 0; i < point;i++)
        {
            if ( pic[temp][i] && --injudge[i] == 0) s.push(i);
            ///如果有线，那么连接的点入度减去一，如果减去一之后为0 的话就入栈
        }
    }
    if ( num != point ) return 1;///有圆圈
    else if ( flag ) return 2;///不确定；
    return 3;///确定
}
int main()
{
    //freopen("in.txt","r",stdin);
    while ( scanf("%d %d",&point,&judge) != EOF )
    {
        if ( point == 0 ) break;
        memset(ins,0,sizeof(ins));
        memset(pic,0,sizeof(pic));
        string j; string ans1="";
        int flag1 = 0; int flag2 = 0;
        for ( int i = 0; i < judge; i++)
        {
            cin >> j;
            if (!flag1 && !flag2)
            {
                char a = j[0]; char b = j[1]; char c = j[2];
                if ( pic[c-'A'][a-'A'] == 1)///如果有反线就输出矛盾；
                {
                    flag2 = 1;
                    printf("Inconsistency found after %d relations.\n",i+1);
                    continue;
                }
                else
                {
                    pic[a-'A'][c-'A'] = 1;
                    ins[c-'A']++;
                }
                int flag3 = judges();///判断函数
                if ( flag3 == 3 )
                {
                    printf("Sorted sequence determined after %d relations: ",i+1);
                    for ( int k = 0; k < point; k++)
                    {
                        ans1 += way[k]+'A';
                    }
                    cout << ans1 << "." << endl;
                    flag1 = 1;
                }else if ( flag3 == 1)
                {
                    printf("Inconsistency found after %d relations.\n",i+1);
                    flag2 = 1;
                }
            }
        }
        if (!flag1&&!flag2)
            printf("Sorted sequence cannot be determined.\n");

    }
}