SDNU 1031.字母排序 拓扑排序

1031.字母排序
Time Limit: 1000 MS    Memory Limit: 32768 KB

Description

有若干个字母，已知它们中某些字母之间的前后关系，求它们的排列顺序。

Input
输入数据包含若干组。
每组数据第一行两个整数N（2 <= N <= 26）、M，为字母的个数及已知条件的个数，字母为从A开始的N个字母。N、M均为0表示输入结束。

之后M行，为一个条件，格式为：字母<字母，或字母>字母，如A<B，代表A在B的前面，A>B代表A在B的后面。

Output
对于每组输入数据，输出包含一行，若确定了字母的顺序，则输出：
Sorted sequence determined after xxx relations: yyy...y.
若发现了矛盾，则输出：
Inconsistency found after xxx relations.
若无法确定全部字母的顺序，则输出：
Sorted sequence cannot be determined.

其中，xxx为已读入的条件的个数，yyy...y为排好序的字母序列。

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.

    题目对所有的字母进行排序，然后如果确定了所有字母的顺序的话，输出这个顺序。其实就是用拓扑排序排一下就可以了，区别在于判断一下是否所有的数都已经确定位置了，如果确定了就输出答案。而且这道题要求输入一句就进行一次判断，如果可以确定就输出结果，如果出现矛盾（成环）也输出结果，然后输出现在已经读入了几个条件。所以这道题需要每一次输入都进行一次拓扑排序。

    下面AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int ma[105][105];
int yindegree[105];
int indegree[105];
char s[15];
bool vis[30];
char ans[105];
bool maxn[105];

int toposort(int a)
{
     int i,j,k;
     int t=0;
     char ss;
     int q=0;
     for(i=1;i<=a;i++)
     {
         if(maxn[i]==0)
            q++;
     }
     if(q>1)
        return 0;
     for(i=1;i<=a;i++)
     {
          for(j=1;j<=a;j++)
          {
               if(indegree[j]==0&&vis[j]==1)
               {
                    indegree[j]--;
                    ss=j+'A'-1;
                    ans[t++]=ss;
                    for(k=1;k<=a;k++)
                    {
                         if(ma[j][k]==1)
                         {
                              indegree[k]--;
                         }
                    }
                    break;
               }
          }
     }
     if(t!=a)
        return 0;
     return 1;
}

int goal(int a)
{
	int i,j,k;
	int flag;
	int in[1005];
	for(i=1;i<=a;i++)
    {
        in[i]=indegree[i];
    }
	for(i=1;i<=a;i++)
	{
		flag=0;
		for(j=1;j<=a;j++)
		{
			if(in[j]==0)
			{
				flag=1;
				in[j]=-1;
				for(k=1;k<=a;k++)
				{
					if(ma[j][k])
                        in[k]--;
				}
				break;
			}
		}
		if(flag==0)
            return 0;
	}
	if(flag==1)
        return 1;
    return 0;
}

int main()
{
    int i,j;
    int x,y;
    int n,m;
    int k;
    int t;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0&&m==0)
            break;
        k=0;
        int fla=0;
        int klag=0;
        memset(ma,0,sizeof(ma));
        memset(indegree,0,sizeof(indegree));
        memset(yindegree,0,sizeof(yindegree));
        memset(vis,0,sizeof(vis));
        memset(maxn,0,sizeof(maxn));
        for(j=1;j<=m;j++)
        {
            t=0;
            memset(ans,0,sizeof(ans));
            //cout<<j<<" : ";
            scanf("%s",s);
            if(fla==1)
                continue;
            if(s[1]=='<')
            {
                x=s[0]-'A'+1;
                y=s[2]-'A'+1;
            }
            else
            {
                y=s[0]-'A'+1;
                x=s[2]-'A'+1;
            }
            vis[x]=1;
            vis[y]=1;
            //scanf("%d%d",&x,&y);
            if(!ma[x][y])
            {
                ma[x][y]=1;
                yindegree[y]++;
                maxn[x]=1;
            }
            for(i=1;i<=n;i++)
            {
                indegree[i]=yindegree[i];
            }
            for(i=1;i<=n;i++)
            {
                if(vis[i]==0)
                {
                    t=1;
                    break;
                }
            }
            if(!goal(n))
            {
                cout<<"Inconsistency found after "<<j<<" relations."<<endl;
                fla=1;
            }
            if(toposort(n)==1&&fla==0&&klag==0)
            {
                cout<<"Sorted sequence determined after "<<j<<" relations: "<<ans<<"."<<endl;
                klag=1;
            }
        }
        if(t==1&&fla==0)
        {
            cout<<"Sorted sequence cannot be determined."<<endl;
        }
    }
    return 0;
}