poj1094（Sorting It All Out）

题目大意：

    输入n，m。n代表有几个大写字母从'A'开始（A、B...）。m代表m对字母的间的关系。通过判断输出数据间的关系。

输出有三种：

一定要理解清楚题目意思！

Sorted sequence determined after 4 relations: ABCD.  
输入前4个关系后，决定出了一个序列（关系总数可能大于4）

Inconsistency found after 2 relations.
输入前2个关系后，冲突出现了（环，关系总数可能大于2）

Sorted sequence cannot be determined.
所有关系输入后，序列和冲突均无出现

解题思路：
    拓扑排序。最重要的是输出，本来以为题目有问题，后来仔细想了想题目的意思。感觉没有什么不对，弄清楚输出的的意思就不会WA。
方法：每输入一组数据就判断一下情况，因为题目的意思是输出的时候是看你通过第几组数据就可以将所有数据判断出来结果，所以需要每次输入都判别一下。
1.如果通过前面t组数据可以判断出n个字母的的顺序即直接输出

Sorted sequence determined after t relations:....
后面无论输入什么数据，或者形成环都不需要问。

2.如果通过前面t组数据可以判断出n个字母形成环即直接输出

Inconsistency found after t relations.

3.如果输入不出现任何矛盾的问题并且判断不出来字母的顺序即输出：

Sorted sequence cannot be determined.

代码：

#include <algorithm>
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <string>
#include <bitset>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
//#include <map>
#include <set>
using namespace std;
/***************************************/
#define ll long long
#define int64 __int64
/***************************************/
const int INF = 0x7f7f7f7f;
const double eps = 1e-8;
const double PIE=acos(-1.0);
const int d1x[]= {0,-1,0,1};
const int d1y[]= {-1,0,1,0};
const int d2x[]= {0,-1,0,1};
const int d2y[]= {1,0,-1,0};
const int fx[]= {-1,-1,-1,0,0,1,1,1};
const int fy[]= {-1,0,1,-1,1,-1,0,1};
/***************************************/
void openfile()
{
    freopen("data.in","rb",stdin);
    freopen("data.out","wb",stdout);
}
/**********************华丽丽的分割线,以上为模板部分*****************/

int map[50][50];
int cnt[50];
int cnt1[50];
int top[50];
int vis[50];
int n,m;
int ce1;
int flag;
int topo(int txt)
{
    int i,j,k;
    int sum=0;
    int d=0;
    int ce4=0;
    memset(top,0,sizeof(top));
    for(i=0; i<n; i++)
    {
        for(sum=0,j=0; j<n; j++)
        {
            if (!cnt[j])
                sum++;
        }
        if (sum>1)
        {
            ce4=1;
        //    if (txt+1==m)
             //   printf("Sorted sequence cannot be determined.
");
         //   return 0;
        }
        for(j=0; j<n; j++)
        {
            if (!cnt[j])
            {
                cnt[j]=-1;
                top[d++]=j;
                for(k=0; k<n; k++)
                {
                    if (map[j][k])
                    {
                        cnt[k]--;
                    }
                }
                break;
            }
        }
    }
    if(ce4&&d==n)
        return 0;
    ce1=txt+1;
    if (d==n)
    {
        flag=1;
        return 0;
    }
    flag=2;
    //if(txt+1==m)
      //  printf("Inconsistency found after %d relations.
",txt+1);
    return 0;
}
int main()
{
    while(scanf("%d%d",&n,&m)&&(n+m))
    {
        int i,j;
        char a,b,c;
        int x,y;
        memset(map,0,sizeof(map));
        memset(vis,0,sizeof(vis));
        memset(cnt,0,sizeof(cnt));
        memset(cnt1,0,sizeof(cnt1));
        for(i=0; i<n; i++)
            cnt[i]=0;
        int ce;
        ce1=0;
        flag=0;
        for(i=0; i<m; i++)
        {
            getchar();
            scanf("%c%c%c",&a,&b,&c);
            x=a-'A';
            y=c-'A';
            if (map[x][y]==0)
            {
                map[x][y]=1;
                cnt1[y]++;
            }
            for(j=0; j<n; j++)
                cnt[j]=cnt1[j];
            if(!ce1)
                topo(i);
        }
        if (flag==1)
        {
            printf("Sorted sequence determined after %d relations: ",ce1);
            for(i=0; i<n; i++)
                printf("%c",top[i]+'A');
            printf(".
");
            continue;
        }
        if (flag==2)
        {
            printf("Inconsistency found after %d relations.
",ce1);
            continue;
        }
        printf("Sorted sequence cannot be determined.
");
    }
    return 0;
}