POJ1094 Sorting It All Out 拓扑排序判大小关系

Sorting It All Out

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 36371		Accepted: 12800

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

#include<stdio.h>
#include<string.h>
#include<vector>
#include<iostream>
using namespace std;
int n,m,cnt;
int degree[30];
bool hp;
bool edges[30][30];
char topo[30];
vector<char>vec;
int toposort()
{
    vec.clear();
    int indegree[30];//函数内部设一个记录入度的数组，尝试着进行拓扑;
    int i,j,k,m;
    memcpy(indegree, degree, sizeof(degree));
    cnt = 0;
    m = 0;//判断是否有多个前驱结点，注意初始化放在外循环外面；
    bool insis=false;
    for(i = 0; i < n; i++)
    {

        bool flag=true;
        for(j = 0; j < n; j++)
        {
            if(indegree[j] == 0)
            {
                flag=false;
                vec.push_back(j+'A');//进拓扑序列；
                indegree[j]--;
                for(k = j+1; k < n; k++)
                {
                    if(indegree[k] == 0)
                        insis=true;//m=1说明有多个前驱结点，拓扑序列不唯一；
                }
                for(k = 0; k < n; k++)
                {
                    if(edges[j][k])
                        indegree[k]--;//与j相连的结点入度减一；
                }
                break;
            }
        }
        if (flag) return -1;
    }
    if (insis) return 0;
    return 1;
}
int main()
{
int i,res;
char u,v;
while(~scanf("%d %d",&n,&m) && m && n)
{
    memset(edges,0,sizeof(edges));
    memset(degree,0,sizeof(degree));
    hp=false;
    getchar();
        for(i = 1; i <= m; i++)
        {
            string rbs;
            if (hp) {getline(cin, rbs); continue;}
            scanf("%c<%c",&u,&v);
            getchar();
            if (edges[u-'A'][v-'A']==0){
                degree[v-'A']++;
                edges[u-'A'][v-'A'] = 1;
            }
            res = toposort();

            if(res == -1)
            {
                //有环时直接输出
                printf("Inconsistency found after %d relations.\n",i);
                hp=true;
            }
            else if(res == 1)
            {   //当只有一个前驱结点时才输出拓扑序列。
                printf("Sorted sequence determined after %d relations: ",i);
                for (int i=0; i<vec.size(); i++) printf("%c",vec[i]);
                printf(".\n");
                hp=true;
            }
        }

if (!hp) printf("Sorted sequence cannot be determined.\n");
}
return 0;
}

不能发现有多个0入度就直接return，因为可能会inconsistent！