P1347 排序

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个元素的顺序后即可结束程序，可以不用考虑确定顺序之后出现矛盾的情况）

输入输出样例

输入样例#1： 

4 6
A<B
A<C
B<C
C<D
B<D
A<B

输出样例#1： 

Sorted sequence determined after 4 relations: ABCD.

输入样例#2： 

3 2
A<B
B<A

输出样例#2： 

Inconsistency found after 2 relations.

输入样例#3： 

26 1
A<Z

输出样例#3： 

Sorted sequence cannot be determined

 

这道题我来提供一种tarjan+拓扑排序的做法，首先我们考虑满足第二种情况的序列，如果存在矛盾，那么这个图中一定存在环，这样我们就可以用tarjan缩点判断一下是否存在环，有一点需要注意，就是如果小于号两边的数相同，那么就一定产生矛盾（非常坑）。对于第一种情况的序列，不难看出这个序列的拓扑序一定是唯一的，而且一定不存在环，也就是说每次拓扑时在栈中的元素一定只有唯一的一个，这样只需在每次拓扑开始时判断一下元素个数即可。如果第一和第二种情况均不满足，那么一定就是第三种情况咯。

最后附上代码：

#include<iostream>
#include<string>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<stack>
#define maxn 1005
using namespace std;

struct edge
{
    int next;
    int to;
}g[maxn<<1];
int n,m,num,col,tot,cnt,pd,cnt2,cc,pd1;
int last[maxn],de[maxn],dfn[maxn],low[maxn],co[maxn],de1[maxn];
char aa[5],bb[maxn];
stack<int>s;
stack<int>ss;

void add(int from,int to)
{
    g[++num].next=last[from];
    g[num].to=to;
    last[from]=num;
}

void topo()
{
    for(int i=1;i<=n;i++)
    {
        if(de1[i]==0)
        {
            ss.push(i);
        }
    }
    while(ss.size())
    {
        if(ss.size()>1)//如果栈中多余一个元素，说明topo序不唯一 
        {
            pd1=1;
            break;
        }
        int u=ss.top();ss.pop();
        bb[++cc]=char(u+'A'-1);
        for(int i=last[u];i;i=g[i].next)
        {
            int v=g[i].to;
            de1[v]--;
            if(de1[v]==0)
            {
                ss.push(v);
            }
        }
    }
}

void tarjan(int u)
{
    dfn[u]=low[u]=++tot;
    s.push(u);
    for(int i=last[u];i;i=g[i].next)
    {
        int v=g[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(!co[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        col++;cnt=0;
        for(;;)
        {
            int x=s.top();s.pop();
            co[x]=col;
            cnt++;
            if(cnt>1) pd=1;//如果一个强联通分量中存在不止一个点，说明有环 
            if(x==u) break;
        }
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%s",aa);
        add(aa[0]-'A'+1,aa[2]-'A'+1);
        if(aa[0]-'A'+1==aa[2]-'A'+1) 
        {
            printf("Inconsistency found after %d relations.",i);//这里需要特判一下，不然第一个点会wa 
            return 0;    
        }    
        de[aa[2]-'A'+1]++;
        de1[aa[2]-'A'+1]=de[aa[2]-'A'+1];
        for(int j=1;j<=n;j++)
        de1[j]=de[j];
        tot=0;col=0;cc=0;pd1=0;
        memset(co,0,sizeof(co));
        memset(dfn,0,sizeof(dfn));
        memset(low,0,sizeof(low));
        while(s.size()) s.pop();
        while(ss.size()) ss.pop();
        for(int j=1;j<=n;j++)
        {
            if(!dfn[j])
            {
                tarjan(j);//tarjan判环 
            }
        }
        if(pd==1) 
        {
            printf("Inconsistency found after %d relations.",i);
            return 0;
        }
        topo();//topo检查topo序是否唯一 
        if(pd1==0)
        {
            printf("Sorted sequence determined after %d relations: ",i);
            for(int j=1;j<=n;j++)
            {
                printf("%c",bb[j]);
            }
            printf(".");
            return 0;
        }
    }
    printf("Sorted sequence cannot be determined.");
    return 0; 
}