POJ：1094-Sorting It All Out（拓扑排序经典题型）

Sorting It All Out

Time Limit: 1000MS Memory Limit: 10000K

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.

---

解题心得：

• 题意就是给你一系列的关系，让你从他给出的关系中从小到大排一个序，如果给出的关系中发生冲突，输出发生冲突的那一步，如果可以得到一个序，输出题目给出到第几个关系才能确定顺序。
• 其实就是给出一个关系，然后拓扑排序判断一下，因为最多只有26个字母，所以怎么写都不会超时。如果题目给出的关系发生冲突，那么必然可以形成环，所以判断环就行，如果能够确定n个点的关系，那么每次只能出现一个出度为0的点，最后n个点的顺序全得到。思路比较简单，只要不手贱写一些BUG那么还是很容易用代码实现的。

---

#include<stdio.h>
#include<algorithm>
#include<set>
#include<stack>
#include<vector>
#include<cstring>
using namespace std;
const int maxn = 100;
char s[maxn];
vector <int> ve[maxn];//用不定长数组来存储边的关系
int out[maxn],n,m;
bool vis[maxn],maps[maxn][maxn];
int ans;
stack <int> st1;
void init()
{
    ans = -1;
    for(int i=0; i<maxn; i++)
        ve[i].clear();
    memset(out,0,sizeof(out));
    memset(maps,0,sizeof(maps));
    memset(vis,0,sizeof(vis));
}

int toposort(int pos)
{
    maps[s[0]][s[2]] = true;
    vis[s[0]] = vis[s[2]] = true;//已经出现了的点
    out[s[0]]++;//出度++
    ve[s[2]].push_back(s[0]);
    int in1[maxn],out1[maxn];
    bool vis1[maxn];
    memcpy(out1,out,sizeof(out));
    memcpy(vis1,vis,sizeof(vis));
    stack<int>st;
    bool flag = false;
    while(1)
    {
        int num = 0;
        vector<int>va;
        for(int i='A'; i<'A'+n; i++)
        {
            if(out1[i] == 0 && vis1[i])//出度为零并且已经出现了的点
                va.push_back(i);
        }
        if(va.size() > 1)//出度为0的点不止一个做好标记
            flag = true;
        if(va.size() == 0)//没有出度为0的点了
            break;

        for(int i=0; i<va.size(); i++)//根据拓扑排序来解决这个出度为0的点
        {
            int k = va[i];
            st.push(k);
            vis1[k] = false;
            for(int j=0;j<ve[k].size();j++)
                out1[ve[k][j]]--;
        }
    }
    int sum2 = 0;
    for(int i='A'; i<'A'+n; i++)//检查是否出现了环
        if(out1[i])
            sum2++;
    if(sum2 != 0)
    {
        //如果有环记录出现环的步数，然后直接返回
        ans = pos;
        return 2;
    }
    if(flag)//出现了多个入度为零的点
        return 1;
    if(st.size() == n)//找到了n个符合拓扑排序的点
    {
        ans = pos;
        st1 = st;
        return 3;
    }
    return 1;//给出的关系不够不能得出答案
}

int main()
{
    while(scanf("%d%d",&n,&m) && n+m)
    {
        init();//初始化一些数组
        bool cont_flag = false;//是否已经出现结果
        int k;
        for(int i=1; i<=m; i++)
        {
            scanf("%s",s);
            if(cont_flag)
                continue;
            if(maps[s[0]][s[2]])//去除重边
                continue;

            k = toposort(i);
            if(k == 2)
                cont_flag = true;
            if(k == 3)
                cont_flag = true;
        }
        if(k != 3 && k != 2)//没找到答案也未出现环，说明给出的关系不足以判断
            printf("Sorted sequence cannot be determined.\n");
        if(k == 2)
            printf("Inconsistency found after %d relations.\n",ans);
        if(k == 3)
        {
            printf("Sorted sequence determined after %d relations: ",ans);
            while(st1.size())
            {
                printf("%c",st1.top());
                st1.pop();
            }
            printf(".\n");
        }
    }
    return 0;
}