poj 1094 Sorting It All Out

Sorting It All Out

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 27962		Accepted: 9666

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.

这道题目是拓扑排序，就是操作烦了点。这道题还有个坑爹的地方，就是一旦找到拓扑序列，直接输出答案，即使后面出现了矛盾。

首先，把n个点看成孤立的点，然后不停地加边（可以有平行边），每加一条边就做一次拓扑排序，刚开始并未出现矛盾，拓扑序列个数为n，但是每次拓扑单次向栈里加元素会超过一个，这表示关系未确定。

之后可能出现三种情况：矛盾（拓扑序列个数小于n），做个标记，以后只需把读入读完，不用做拓扑排序了。

找到序列（拓扑序列个数为n，并且单次入栈仅有1个元素），同样做个标志，以后只需把读入读完，不用做拓扑排序了。 没有找到序列并且不矛盾，（拓扑序列个数为n，并且某次入栈超过1个元素），继续读入数据并加边，做拓扑排序。

这样并且需要记录前几句话可以判断，只需在标志位改变同时，记录第几句话就可以了，然后每次用一个数组在拓扑排序时，记录拓扑序列，方便打印。

代码：

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;

char s[4],ret[26];
int adj[26][26],indeg[26],cp[26];
int topo_sort(int n){
    int top=-1,cnt=0,ans=0,tot=0;
    memmove(cp,indeg,sizeof(int)*n);
    for(int i=0;i<n;i++)
        if(!cp[i]) cp[i]=top,top=i,cnt++;
    int maxx=cnt;
    while(top!=-1){
        int j=top;
        ret[tot++]='A'+j;
        top=cp[top],cnt=0,ans++;
        for(int i=0;i<n;i++)
            if(adj[j][i])
                if(!(cp[i]-=adj[j][i])) cp[i]=top,top=i,cnt++;
        maxx=max(cnt,maxx);
    }
    ret[tot]='\0';
    if(ans!=n) return 0;
    return maxx;
}
int main()
{
    int n,m,res;
    while(scanf("%d%d",&n,&m),n){
        memset(adj,0,sizeof adj);
        memset(indeg,0,sizeof indeg);
        bool flag=true,first=true;
        for(int i=1;i<=m;i++){
            scanf("%s",s);
            if(!flag||!first) continue;
            int p=s[0]-'A',q=s[2]-'A';
            adj[p][q]++;
            indeg[q]++;
            int maxx=topo_sort(n);
            if(!maxx) res=i,flag=false;
            else if(maxx==1&&first) res=i,first=false;
        }
        if(!flag) printf("Inconsistency found after %d relations.\n",res);
        else if(first) puts("Sorted sequence cannot be determined.");
        else printf("Sorted sequence determined after %d relations: %s.\n",res,ret);
    }
	return 0;
}