poj 1094 Sorting It All Out (拓扑排序)

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

Sorting It All Out

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 24505		Accepted: 8487

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

 

【题解】：

　　拓扑排序到底就行，注意：

　　　　当遇到两个入度为0的情况，需要判断是否出现环

　　唉，不说了，代码写得真挫，乱七八糟，不过能AC

　　　

【code】：

/**
Judge Status:Accepted    Memory:704K
Time:0MS     Language:G++
Code Lenght:2296B   Author:cj
*/

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>

#define N 30
#define M N*N
using namespace std;

int map[N][N],mark[N],in[N],tin[N];
char anstr[N];
int n,flag;

void init()
{
    memset(map,0,sizeof(map));
    memset(mark,0,sizeof(mark));
    memset(in,0,sizeof(in));
    memset(tin,0,sizeof(tin));
}

int topCheck(int id)  //拓扑排序
{
    int i,cnt=0,pos=-1;
    for(i=0;i<26;i++)
    {
        if(mark[i]&&!in[i])
        {
            cnt++;
            pos=i;
        }
    }
    if(cnt>1)  //当有多个入度为0的点
    {
        flag = 1;  //标记出现多个入度为0的点的情况
        in[pos] = -1;
        anstr[id] = pos+'A';
        for(i=0;i<26;i++)
        {
            if(map[pos][i])     in[i]--;
        }
        return topCheck(id+1);
    }
    if(cnt==0)
    {
        for(i=0;i<26;i++)
        {
            if(mark[i]&&in[i]>0)  
            {
                return 1;   //入度都大于0，出现了环
            }
        }
        if(id!=n||flag)   return 0;  //当排序到入度为0时，并且一直没有出现过多个入度为0的情况，则排序可以完成
        anstr[id]='';
        return 2;
    }
    in[pos] = -1;
    anstr[id] = pos+'A';
    for(i=0;i<26;i++)
    {
        if(map[pos][i])     in[i]--;
    }
    return topCheck(id+1);  //进入下一层拓扑排序
    return 0;
}

int main()
{
    int m;
    while(~scanf("%d%d",&n,&m))
    {
        if(!n&&!m)  break;
        char xx[5];
        int i;
        init();
        int temp=0,pos=0;
        for(i=1;i<=m;i++)
        {
            scanf("%s",xx);
            int x = xx[0]-'A';
            int y = xx[2]-'A';
            mark[x] = mark[y] = 1;
            tin[y]++;
            map[x][y] = 1;
            memcpy(in,tin,sizeof(int)*26);
            if(temp!=0)  continue;
            flag = 0;
            temp = topCheck(0);
            pos = i;
        }
        if(temp==2)
        {
            anstr[pos+i]='';
            printf("Sorted sequence determined after %d relations: %s.
",pos,anstr);
            continue;
        }
        if(temp==1)
        {
            printf("Inconsistency found after %d relations.
",pos);
            continue;
        }
        puts("Sorted sequence cannot be determined.");
    }
    return 0;
}