Sorting It All Out 拓扑

Sorting It All Out

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 33871		Accepted: 11858

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 Code
 
 
Problem: 1094
 
User: 
Memory: 720K
 
Time: 0MS
Language: G++
 
Result: Accepted
 
 
Source Code
#include <iostream>
#include<string.h>
#include<queue>
#include<vector>
#include<cstdio>
#include<algorithm>
using namespace std;
const int Maxn=105;
int n,m,in[Maxn],temp[Maxn],Sort[Maxn],t,pos,num;
char X,O,Y;
vector<int>G[Maxn];
queue<int>q;
void init()
{
  memset(in,0,sizeof(in));
  for(int i=0;i<=n;i++)
  G[i].clear();
}
inline bool Find(int u,int v)
{
   for(int i=0;i<G[u].size();i++)
   if(G[u][i]==v) return true;
   return false;
}
int topoSort()
{

   while(!q.empty()) q.pop();
   for(int i=0;i<n;i++)
   if(in[i]==0)
   q.push(i);
    pos=0;
    int unSure=0;
    while(!q.empty())
    {
       if(q.size()>1) unSure=1;
       int t=q.front();
       q.pop();
       Sort[pos++]=t;
       for(int i=0;i<G[t].size();i++)
       if(--in[G[t][i]]==0)
       q.push(G[t][i]);
    }
    if(pos<n) return 1;
    if(unSure) return 2;
    return 3;
}
int main()
{
    int x,y,i,flag,ok,stop;
    while(~scanf("%d%d%*d",&n,&m))
    {
       if(!n||!m) break;
       init();
       flag=2;
       ok=0;
       for(i=1;i<=m;i++)
       {
          scanf("%c%c%c%*c"
          ,&X,&O,&Y);
          if(ok) continue;
          x=X-'A',y=Y-'A';
          if(O=='<'&&!Find(y,x))
          {
            G[y].push_back(x);
            ++in[x];
          }
          else if((O=='>'&&!Find(x,y)))
          {
            G[x].push_back(y);
            ++in[y];
          }
          memcpy(temp,in,sizeof(in));
          flag=topoSort();
          memcpy(in,temp,sizeof(temp));
          if(flag!=2)
          {
            stop=i;ok=1;
          }
       }
       if(flag==3)
       {
          printf("Sorted sequence determined after %d relations: ",stop);
          for(int i=pos-1;i>=0;i--)
          printf("%c",Sort[i]+'A');
          printf(".\n");
       }
       else if(flag==1)
       printf("Inconsistency found after %d relations.\n",stop);
       else
       printf("Sorted sequence cannot be determined.\n");

    }
    return 0;
}