Sorting It All Out POJ - 1094

Sorting It All Out

POJ - 1094

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.

//#include<bits/stdc++.h>
#define _CRT_SBCURE_NO_DEPRECATE
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <functional>
//#define UP(i,x,y) for(int i=x;i<=y;i++)
//#define DOWN(i,x,y) for(int i=x;i>=y;i--)
#define sdddd(x,y,z,k) scanf("%d%d%d%d", &x, &y, &z, &k)
#define sddd(x,y,z) scanf("%d%d%d", &x, &y, &z)
#define sdd(x,y) scanf("%d%d", &x, &y)
#define sd(x) scanf("%d", &x)
#define mp make_pair
#define pb push_back
#define lson k<<1
#define rson k<<1|1
#define mid (l+r)/2
#define ms(x, y) memset(x, y, sizeof x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
//#define MOD 142857
const int maxn = 30;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
int n, m, s, t;
int len;
struct edge
{
    int u, v;
    int next;
};
edge G[maxn<<4];
int h[maxn];
int arr[maxn];
int enter[maxn];
int aans[maxn];
void init()
{
    for(int i = 0; i < maxn; i++){arr[i] = 0; h[i] = -1;}
}
int main()
{
	//freopen("out.txt", "w", stdout);
	while(~sdd(n, m) && (n||m))
    {
        init();
        char str[5];
        int flag = 0;
        len = 0;
        int ans;
        for(int i = 0; i < m; i++)
        {
            scanf("%s", str);
            arr[str[2]-'A']++;
            G[len].u = str[0] - 'A';
            G[len].v = str[2] - 'A';
            G[len].next = h[str[0] - 'A'];
            h[str[0] - 'A'] = len++;
            memcpy(enter, arr, sizeof arr);
            int cnt = 0;
            queue<int> que;
            for(int j = 0; j < n; j++)
            {
                if(enter[j] == 0)
                    que.push(j);
            }
            int ff = 0;
            while(que.size())
            {
                if(que.size() > 1)
                {
                    ff = 1;
                    break;
                }
                int v = que.front(); que.pop();
                aans[cnt++] = v;
                for(int j = h[v]; j != -1; j = G[j].next)
                {
                    edge e = G[j];
                    enter[e.v]--;
                    if(enter[e.v] == 0)
                        que.push(e.v);
                }
            }
            if(ff)
            {
                while(que.size())
                {
                    int v = que.front(); que.pop();
                    aans[cnt++] = v;
                    for(int j = h[v]; j != -1; j = G[j].next)
                    {
                        edge e = G[j];
                        enter[e.v]--;
                        if(enter[e.v] == 0)
                            que.push(e.v);
                    }
                }
                if(!flag && cnt < n)
                {
                    flag = 1;ans = i+1;
                }
                continue;
            }
            if(!flag && cnt == n)
            {
                flag = 2;ans = i+1;
            }
            if(!flag && cnt < n)
            {
                flag = 1;ans = i+1;
            }
        }
        if(!flag)
        {
            puts("Sorted sequence cannot be determined.");
        }
        else if(flag == 2)
        {
            printf("Sorted sequence determined after %d relations: ", ans);
            for(int i = 0; i < n; i++)
                printf("%c", 'A'+aans[i]);
            puts(".");
        }
        else if(flag == 1)
        {
            printf("Inconsistency found after %d relations.\n", ans);
        }

    }
	return 0;
}

Preview: