POJ 1094 Sorting It All Out

题目链接：POJ 1094

Describe:

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.

题目大意：

给n个连续的字母，m个判断语句，问在得到多少语句之后可以判断出这些字母构成一个环，或者一个排序，亦或者不能确定。

解题思路：

每次读入一组数据，就拓扑排序判断一下，具体见代码的详细注释。根据题意和输入输出，会发现此题跟图有关，从而想到最终的排序用拓扑排序。

此题也附上快150行的的一次写的错误代码，想的太复杂了。

AC代码：

 

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
// arr用来存储图，in用来存储入度，ans用来存储排好序的序列
int arr[26][26],in[26],ans[26];
void init(int n) // 初始化函数
{
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            arr[i][j] = 0;
    for(int i = 0; i < n; i++)
        in[i] = 0;
}
int topo(int n)
{
    int tmp[26],t,f = 1,cont = 0;
    for(int i = 0; i < n; i++) tmp[i] = in[i]; // 临时数组复制入度数组，防止入度数组改变
    for(int i = 0; i < n; i++)
    {
        cont = 0; // 表示入度为0的个数
        t = -1; // 存储入度为0的序号
        for(int j = 0; j < n; j++) // 循环寻找入度为0的
        {
            if(tmp[j] == 0)
            {
                cont++;
                t = j;
            }
        }
        if(cont > 1) f = 0; // 如果入度为零的数目大于1，说明暂时不能确定，但是不能直接return
        // 因为可能还存在成环的情况我们没有检测出来，所以先记录下来
        if(cont == 0) return 2; // 如果没有一个入度为0的，说明成环了
        ans[i] = t; // 记录到答案数组
        tmp[t] = -1; // 注意，不能忘记这一步，表示该点已经搜索到过了，不能重复搜索
        for(int j = 0; j < n; j++) // 相连的点入度都减一
            if(arr[t][j] == 1)
                tmp[j]--;
    }
    return f;
}
int main()
{
    int n,m,x,y,f,cnt,t; // n，m，a，b，c为题目变量，f为标志，cnt为计数器，t为中间变量
    char a,b,c;
    while(~scanf("%d%d",&n,&m) && n+m)
    {
        cnt = 0; // 各种初始化
        f = 1;
        init(n);
        while(m--)
        {
            scanf("\n%c%c%c",&a,&b,&c);
            if(f == 1)
            {
                x = a-'A'; // 数据类型转换
                y = c-'A';
                arr[x][y] = 1; // 有向图添加一条边
                in[y]++; // 入度加一
                cnt++;
                t = topo(n); // 进行一次判断
                if(t == 1) // 如果能排序
                {
                    printf("Sorted sequence determined after %d relations: ",cnt);
                    for(int i = 0; i < n; i++) printf("%c",ans[i]+'A');
                    printf(".\n");
                    f = 0;
                } else if(t == 2) { // 如果成环
                    printf("Inconsistency found after %d relations.\n",cnt);
                    f = 0;
                }
            }
        } // 如果最终都没确定，则无法确定
        if(f == 1) printf("Sorted sequence cannot be determined.\n");
    }
    return 0;
}

 

 

 

错误代码：

 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;
struct node
{
    int time,id,ex;
    node *next;
} arr[26];
int n,m,flag,cnt,f[26],d[26],bp[26];
void backup(int n)
{
    for(int i = 0; i < n; i++)
        bp[i] = arr[i].time;
}
void recover(int n)
{
    for(int i = 0; i < n; i++)
        arr[i].time = bp[i];
    memset(bp,0,sizeof(bp));
}
void init(int n)
{
    for(int i = 0; i < n; i++)
    {
        arr[i].id = i;
        arr[i].ex = 0;
        arr[i].time = 0;
        arr[i].next = NULL;
    }
    for(int i = 0; i < n; i++)
        f[i] = 0;
}
int num(int n)
{
    for(int i = 0; i < n; i++)
    {
        if(arr[i].time == 0 && f[i] == 0 && arr[i].ex == 1)
        {
            return i;
        }
    }
    return -1;
}
bool check(int n)
{
    backup(n);
    int t;
    while(true)
    {
        t = num(n);
        if(t == -1) break;
        f[t] = 1;
        node *tmp = arr[t].next;
        while(tmp != NULL) {arr[tmp->id].time--;tmp = tmp->next;}
    }
    for(int i = 0; i < n; i++)
    {
        if(f[i] == 0 && arr[i].ex == 1)
            return false;
    }
    return true;
}
bool istopo(int n)
{
    for(int i = 0; i < n; i++)
        if(arr[i].ex == 0)
            return false;
    return true;
}
void topo(int n)
{
    int t;
    while(true)
    {
        t = num(n);
        if(t == -1) break;
        f[t] = 1;
        node *tmp = arr[t].next;
        while(tmp != NULL) {arr[tmp->id].time--; tmp = tmp->next;}
        printf("%c",t+'A');
    }
}
void dfs(int t)
{
    d[t] = 1;
    node *tmp = arr[t].next;
    while(tmp != NULL)
    {
        dfs(tmp->id);
        tmp = tmp->next;
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m) && n+m)
    {
        memset(d,0,sizeof(d));
        memset(f,0,sizeof(f));
        flag = -1; //-1表示正常，-2表示不能拓扑，-3表示可以拓扑
        cnt = 0;
        init(n);
        int x,y;
        char a,b,c;
        while(m--)
        {
            scanf("\n%c%c%c",&a,&b,&c);
            if(flag == -1)
            {
                x = a-'A';
                y = c-'A';
                node *tmp = (node*)malloc(sizeof(node));
                node *temp = &arr[x];
                while(temp->next != NULL) temp = temp->next;
                tmp->id = y;
                tmp->next = NULL;
                temp->next = tmp;
                arr[x].ex = 1;
                arr[y].ex = 1;
                arr[y].time++;
                cnt++;
                if(!check(n)) flag = -2;
                recover(n);
                memset(f,0,sizeof(f));
                if(istopo(n) && flag == -1) flag = -3;
            }
        }
        if(flag == -2) printf("Inconsistency found after %d relations.\n",cnt);
        else if(flag == -3) {
            printf("Sorted sequence determined after %d relations: ",cnt);
            topo(n);
            printf(".\n");
        } else if(flag == -1) {
            dfs(num(n));
            int ff = 1;
            for(int i = 0; i < n; i++)
                if(d[i] == 0)
                    ff = 0;
            if(ff == 0) printf("Sorted sequence cannot be determined.\n");
            else {
                printf("Sorted sequence determined after %d relations: ",cnt);
                topo(n);
                printf(".\n");
            }
        }
    }
    return 0;
}

 

 

 

Tips:

关于拓扑排序，一般用删边法，即找到一个入度为0的点并输出，然后删掉这个点，并且同时删掉跟它相连的边，然后重复上述步骤。这个方法也可以用来判断图中是否存在回路。（判断图是否连通用dfs）