POJ1094-Sorting It All Out 拓扑排序

题目链接：http://poj.org/problem?id=1094

题目大意：给定n,m。n表示要判断关系的字母个数，m表示提供的字母关系个数，例A<B，则表示 A在B前面。

(1)根据输入的关系序列，判断是否存在环，若存在，则输出你是在观察到第几个关系序列后发现存在环的。

3 2

A<B

B<A

我们发现当关系输入第二个后，我们能判断出这个关系有环，则输出“Inconsistency found after 2 relations.”

(2)若不存环在则判断是否能根据输入的m个关系序列决定这n个字母的关系，不能则输出“Sorted sequence cannot be determined.”

26 1

A<Z

根据输入的关系我们只能决定两个字母的关系，少于要输入的字母个数。

(3)若能决定这n个字母的关系，则输出你是观察到第几个关系序列后得到这n个字母的关系的。

4 6
A<B
A<C
B<C
C<D
B<D
A<B

根据输入的关系我们只要看到第四个就能得到 ABCD这样的关系序列，则输出

Sorted sequence determined after 4 relations: ABCD.

除了不能决定关系序列这个关系外，其他的两个关系没有优先级，不能全部输入后判断

例：

4 5 

A<B

A<C

B<C

C<D

D<A

全部关系形成了一个环，但是根据前四个关系便能判断出这个序列为ABCD,则输出

Sorted sequence determined after 4 relations: ABCD.

题目思路：根据上面的题意分析，解决这个问题我们可以一边输入一边进行拓扑排序，设定一个标记变量：determined{-1,0,1}分别表示存在环，不能决定序列关系，和能决定序列关系。若存在环则以后不需要继续排序。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAX 30
int map[MAX][MAX];
int count[MAX],temp[MAX];
int alpha[MAX];
int n,m;
char s[5];
char sqre[MAX];
int topsort(int x)
{
    int i,j;
    int flag=1,r=0;
    for (i=0;i<n;i++)
    {
        temp[i]=count[i];
    }
    while (x--)
    {
          int cnt=0;
          for (i=0;i<n;i++)
          {
             if (temp[i]==0) 
             {
                j=i;
                cnt++;                 
             }  
          } 
          if (cnt>=1)
          {
             if (cnt>1)
                flag=0;
             for (i=0;i<n;i++)
             {
                 if (map[j][i])
                 {
                    temp[i]--;              
                 }    
             }
             temp[j]=-1;
             sqre[r++]='A'+j;
             sqre[r]='\0';
          }
          else if (cnt==0)
               return -1;  
    }
    if (flag)
       return r;  
    return 0;  
}
int main()
{
    while (~scanf("%d%d",&n,&m))
    {
          if (n==0&&m==0)
             break;
          int i,j;
          int determined=0,c=0,k;
          memset(map,0,sizeof(map));
          memset(alpha,0,sizeof(alpha));
          memset(count,0,sizeof(count));
          for (i=0;i<m;i++)
          {
              scanf("\n%s",s);   
              if (!map[s[0]-'A'][s[2]-'A'])
                 count[s[2]-'A']++;
              map[s[0]-'A'][s[2]-'A']=1;
              if (!alpha[s[0]-'A'])
              {                 
                 alpha[s[0]-'A']=1;
                 c++;
              }
              if (!alpha[s[2]-'A'])
              {
                 alpha[s[2]-'A']=1; 
                 c++;   
              }
              if (determined==0)
              {
                 int t=topsort(c);                    
                 if (t==-1)
                 {
                    determined=-1;
                    k=i+1;
                 }
                 else if (t==n)
                 {
                      determined=1;
                      k=i+1;
                 }
              }       
          }    
          //printf("%s\n",sqre);
          if (determined==-1)
             printf("Inconsistency found after %d relations.",k);
          else if (determined==0)
             printf("Sorted sequence cannot be determined.");
          else
             printf("Sorted sequence determined after %d relations: %s.",k,sqre);   
          printf("\n");
    }
    return 0;    
}