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;    
}