P1347 排序

这道题一看就是拓扑排序，不过细节特别要注意。

题目中说了，如果某一步能判断n个字母的大小关系，那么就输出第几步，并输出从小到大的序列，例如样例1就是第4步就可以判断大小关系了，后面说的看都不用看

如果某一步会导致矛盾，就输出导致矛盾的那一步。例如上面的样例2第2步可以判断发生矛盾

如果遍历完所有步数都不能判断大小关系，也不能判断矛盾关系，那么就是不能确定了，输出即可。

思路：对于每次输入一个字符串,我们都建议一条有向边。然后进行拓扑排序。

1.我们如何去判断是否产生矛盾呢? 我们先这样，每次输入字符串建立有向边以后，我们都把此时输入的字符标记为出现过，然后在拓扑排序函数里面里统计有num个。然后进行拓扑排序，如果出队的节点的个数不等于num，那么就说明此时会发生矛盾（有环）。

如图所示，上面的到了第三步我们用拓扑排序，就会发现，出队数量不等于节点的个数。此时直接输出即可。

2. 我们如何判断 根据前面i步可以确定大小关系呢？
   同样的，我们只需要判断拓扑排序出队的节点数等于n，并且。top排序的时候不会出现有两个节及以上点的的入度同时减为0，因为这样就没法判断大小关系了。

如图所示，压根没办法确定B和D的大小关系（从而导致没办法确定C,E的大小关系），因为A连着B和D，他们两个的入度在拓扑排序时会同时减为0.

前面两个是判断是否会产生矛盾，是否可以判定大小关系。那么如果我们建立所有边的关系以后，以上两个条件在每次拓扑排序的时候都不会满足，就说明无法判断排序的大小关系。

这里一定要注意：是所有的边全部建立以后才能判断是否无法判断大小关系。

下面是AC代码~

#include<iostream>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
#define Max 100
vector<int > Graph[Max];//有向图
int rd[Max]; //记录某个节点的入度。
bool flag[Max];//判断某个字符是否输入
bool flags=false;//判断是否无法判断大小关系
vector<int > res; //将我们topsort的出队节点顺序的保存下来
int n,m;
int topsort();
    int main()
    {
        string str;
        cin>>n>>m;
        int x1,x2;
        memset(rd,0, sizeof(rd));
        memset(flag,false, sizeof(flag));
        for(int i=1;i<=m;i++)
        {
            cin>>str;
            Graph[str[0]-'A'+1].push_back(str[2]-'A'+1);
            flag[str[0]-'A'+1]=flag[str[2]-'A'+1]=true;
            rd[str[2]-'A'+1]++;
            res.clear();
            int b=topsort();
            if(b==1)
            {
                cout<<"Sorted sequence determined after "<<i<<" relations: ";
                for(vector<int >::iterator it=res.begin();it!=res.end();it++)
                {
                    cout<<char(*it-1+'A');
                }
                cout<<".";
                flags=true;
                break;
            }
            else if(b==-1)
            {
                cout<<"Inconsistency found after "<< i <<" relations.";
                flags=true;
                break;
            }
        }
        if(!flags)
        {
          cout<<"Sorted sequence cannot be determined.";
        }
        return 0;
    }

    int topsort()
    {
        int cou=0;
        int t=0,num=0,number=0;
        int r[Max];
        for(int i=1;i<=26;i++) //拷贝一份入度的信息.
        {
            r[i]=rd[i];
        }
        for(int i=1;i<=26;i++)
        {
            if(flag[i]) //如果有这个节点
            {
                num++;
            }
        }
        queue<int> que;
        for(int i=1;i<=26;i++)
        {
            if(flag[i]&&rd[i]==0)
            {
                if(rd[i]==0)
                {
                    que.push(i);
                    cou++;
                }
            }
        }
        if(cou>1) //一个节点可以引出多个入度为0的节点
        {
            t=1;
        }
        while(!que.empty())
        {
            cou=0;
            int u=que.front();
            que.pop();
            number++;
            res.push_back(u);
            for(int i=0;i<Graph[u].size();i++)
            {
                int v=Graph[u][i];
                r[v]--;
                if(r[v]==0)
                {
                    que.push(v);
                    cou++;
                    if(cou>1)
                    {
                        t=1; //如果后面还有节点的入度数大于1
                    }
                }
            }
        }

        if(number!=num)//如果不相等 说明有环
        {
            return -1;
        }
        else if(t==0&&number==n) //可以判定大小关系
        {
            return 1;
        }
        else //待定，暂时无法判断是否可以判断
        {
            return 0;
        }
    }