P1347 排序

一个不同的值的升序排序数列指的是一个从左到右元素依次增大的序列，例如，一个有序的数列A,B,C,D 表示A<B,B<C,C<D。在这道题中，我们将给你一系列形如A<B的关系，并要求你判断是否能够根据这些关系确定这个数列的顺序。
输入格式

第一行有两个整数n,m，n表示需要排序的元素数量，2<=n<=26，第1到n个元素将用大写的A,B,C,D…表示。m表示将给出的形如A<B的关系的数量。

接下来有m行，每行有3个字符，分别为一个大写字母，一个<符号，一个大写字母，表示两个元素之间的关系。
输出格式

若根据前x个关系即可确定这n个元素的顺序yyy…y（如ABC），输出

Sorted sequence determined after xxx relations: yyy…y.

若根据前x个关系即发现存在矛盾（如A<B,B<C,C<A），输出

Inconsistency found after 2 relations.

若根据这m个关系无法确定这n个元素的顺序，输出

Sorted sequence cannot be determined.

（提示：确定n个元素的顺序后即可结束程序，可以不用考虑确定顺序之后出现矛盾的情况）

思路：计算顺序第一反应肯定就是拓扑排序，但因为问题中有三个问，能全部跑完为第几步，元素是否会有矛盾，能否确定n个元素的关系，因为数据非常小，只有26，所以可以直接，每次输入一次字符，就进行一次拓扑排序，并且用一个flag表示三种情况最终是哪一种，进行拓扑排序时，计算每一个输入字符的深度，如果深度为n那么表明肯定是可以确定这n个数关系的，如果再一次拓扑排序中，有字符没有进过队列，那么，肯定存在某些字符有矛盾，如果不是以上两种情况，那么肯定就是第三种。

#include <cstdio>
#include <cmath>
#include <stack>
#include <queue>
#include <string>
#include <iostream>
#include <ostream>
#include <cstring>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <map>
#include<iomanip>
#define INT_MINs -2000000000
#define INT_MAXs 1000000001
#define mod 1000000007
#define MID mid=(l+r)/2
#define REP1(i,x,y) for(int i=x;i<y;i++)
#define REP2(i,x,y) for(int i=x;i<=y;i++)
#define ls (2*k)
#define lr (2*k+1)
#define lson l,mid,2*k
#define lron mid+1,r,2*k+1
#define inf 0x3f3f3f3f3f3f3f3f
#define IOS ios::sync_with_stdio(0);
#define pb(a) push_back(a)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int dx[4] = { 0,-1,0,1 }, dy[4] = { 1,0,-1,0 };
vector<int>vt[30];
int vis1[30],vis2[30],n,m,flag=0,pos;
char str1[5];
char str2[30];
int maps[30];

struct node{
    int u,deep;
};
void tp(int p)
{
    for(int i=1;i<=26;i++)
        vis2[i]=vis1[i];
        int flag2=0;
        queue<node>q;
    for(int i=1;i<=26;i++)
    {
        if(!vis2[i]&&maps[i])
            {
                q.push(node{i,1});
                flag2=1;
            }
    }
    int ans=1,p1=0;
    char str3[30];
    while(!q.empty())
    {
        node q1=q.front();
        q.pop();
        str3[p1++]=q1.u+'A'-1;
        for(int i=0;i<vt[q1.u].size();i++)
        {
            int v=vt[q1.u][i];
            vis2[v]--;
            if(!vis2[v])
            {
                q.push(node{v,q1.deep+1});
                ans=q1.deep+1;
            }
        }
    }
    if(flag==0)
    {
        if(ans==n)
        {
            flag=1;
            pos=p;
            str3[p1+1]='\0';
            strcpy(str2,str3);
        }
        int sum=0;
        for(int i=1;i<=26;i++)
            if(vis2[i])
                sum++;
        if(sum)
        {
            flag=-1;
            pos=p;
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        cin>>str1;
        int k1=str1[0]-'A'+1,k2=str1[2]-'A'+1;
        if(str1[1]=='>')
        {
            vt[k2].pb(k1);
            vis1[k1]++;
            maps[k1]=maps[k2]=1;
        }
        else
        {
            vt[k1].pb(k2);
            vis1[k2]++;
            maps[k1]=maps[k2]=1;
        }
        tp(i);
    }
    if(flag==1)
        printf("Sorted sequence determined after %d relations: %s.\n",pos,str2);
    else if(flag==-1)
        printf("Inconsistency found after %d relations.\n",pos);
    else
        printf("Sorted sequence cannot be determined.\n");
    return 0;
}