poj1094 Sorting It All Out-优快云博客

本文深入探讨了排序算法的原理、实现及其在不同场景中的应用，包括时间复杂度、空间复杂度分析，以及如何选择合适的排序算法以提高效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Sorting It All Out

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 30315		Accepted: 10506

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.

题目描述：

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

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

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

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

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

#include<stdio.h>
#include<string.h>
int maps[30][30]; //表示点与点之间的连通性
int degree[30];  //记录有向边末端的度
int vist[30];  //存储拓扑排序的顺序
int n,m; //结点数，关系数
int toposort()   //拓扑排序
{
    int i,j;
    int temp[30];  //临时存储各个点的入度
    memset(vist,0,sizeof(vist));
    for(i=1;i<=n;i++)
    {
        temp[i]=degree[i];
    }
    int c=0;  //
    int tenum,counts; //tenum : 记录入度为0的点，counts: 记录入度为0 的点的数目
    int flag=1; //标记变量
    for(i=1;i<=n;i++)
    {
        counts=0;
        for(j=1;j<=n;j++)
        {
            if(!temp[j])
            {
                counts++;
                tenum=j;
            }
        }
        if(counts==0)  return 0; //说明有环存在，直接返回
        if(counts>1)  //说明入度为0 的点不止一个，则不能判断是否有序，则要判断图中是否有环
        flag=-1;
        vist[c++]=tenum;
        temp[tenum]=-1;
        for(j=1;j<=n;j++)
        {
            if(maps[tenum][j])  //所有与tenum有关的点的度减1
            temp[j]--;
        }
    }
    return flag;
}
int main()
{
    char str[10];
    int i;
    while(~scanf("%d%d",&n,&m))
    {
        if(n==0&&m==0)  break;
        memset(maps,0,sizeof(maps));
        memset(degree,0,sizeof(degree));
        int flagnum,ats=0;//flagnum: 标记找到环时或找到合法拓扑排序时的标记
        for(i=1;i<=m;i++)  //ats:判断是否找到环或找到合法拓扑排序
        {
            scanf("%s",str);
            if(ats)   
            continue;
            int a=str[0]-'A'+1;
            int b=str[2]-'A'+1;
            maps[a][b]=1;
            degree[b]++;
            int ans=toposort();
            if(ans==0)  //存在环
            {
                ats=1;
                flagnum=i;
            }
            else if(ans==1)  //已找到合法拓扑排序
            {
                ats=2;
                flagnum=i;
            }
        }
        if(!ats)
        {
            printf("Sorted sequence cannot be determined.\n");
        }
        else if(ats==1)
        {
            printf("Inconsistency found after %d relations.\n",flagnum);
        }
        else if(ats==2)
        {
            printf("Sorted sequence determined after %d relations: ",flagnum);
            for(i=0;i<n;i++)
            {
                printf("%c",vist[i]+'A'-1);
            }
            printf(".\n");
        }
    }
    return 0;
}