POJ1094 Sorting It All Out 拓扑排序（深搜）

题意：给定n和m，n表示大写字母的前n个，m表示m个关系对，求能否确定唯一排序。

分析：分三种情况

（1）当输入完当前的关系对之后，已经能确定矛盾（不需要完全输入m个关系对时）

eg. 3 3

      A<B

      B<A

        B<C

      当输入到第二对已经能判断矛盾，此时记下当前的所需要用到的关系对数ans=2；

      接着输入，但是后面的关系对不作处理

（2） 当输入完当前的关系对之后，已经能确定唯一排序（不需要完全输入m个关系对，

   但是必须n个字母必须都出现，此时后面即使的关系再有矛盾时也不管）

   eg. 4 4

 A<B

 C<D

 B<C

 D<C

当输入到第三对时已经确定唯一序列ABCD，记录此时用到的关系

对数ans=3，接着输入，但是后面的关系对不作处理，即使后面出现矛盾

（3）当所有的关系对数都输入后，还无法确定唯一序列或者矛盾，则说明序列不唯一

（必须输入所有序列）

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int g[30][30];
struct Node{
    int in;
    char c;
}node[30];
Node cpy[30];
bool cmp(Node a,Node b) {
    return a.in<b.in;
}
char s[30];
char p[30];
int mark[30];
int n,m,ans;
int stop()
{
    mark[s[0]-'A'+1]++;
    mark[s[2]-'A'+1]++;
    for(int i=1;i<=n;i++)
    {
        if(!mark[i]) return 0;
    }
    return 1;
}
int dfs(int d)              //深搜
{
    if(d>n) return 1;       //搜完n个点退出，(1)如果此时ans没被改变，说明n个点已经成功完成排序
    sort(node+d,node+1+n,cmp);
    if(node[d].in) {    //(3).如果入度为0的点，退出且返回0；
        return 0;
    }
    else{
        if(d<n&&!node[d+1].in) ans=-1;  //(2).如果有两个以上的点入度为0，ans=-1；
        p[d]=node[d].c;                 //排序后的字母放在p数组；
        for(int i=1;i<=n;i++) if(g[node[d].c-'A'+1][node[i].c-'A'+1]) node[i].in--;
        return dfs(d+1);
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF&&(m||n))
    {
        for(int i=1;i<=n;i++) {
            node[i].in=0;
            node[i].c='A'-1+i;
        }
        memset(g,0,sizeof(g));
        memset(mark,0,sizeof(mark));
        int k=0;
        int flag=-1;
        for(int i=1;i<=m;i++){
            scanf("%s",s);
            if(flag==0||(k&&ans>0)) continue;//如果之前已经发现矛盾，或者已经完成排序，只输入不进行其他操作
            if(!g[s[0]-'A'+1][s[2]-'A'+1]) node[s[2]-'A'+1].in++;
            g[s[0]-'A'+1][s[2]-'A'+1]=1;//标记边，下次出现此边时不更新点
            ans=0;
            if(!k) k=stop();            //判断所有点是否都出现过
            for(int j=1;j<=n;j++){      //备份点
                cpy[j].c=node[j].c;
                cpy[j].in=node[j].in;
            }
            flag=dfs(1);                //深搜
            for(int j=1;j<=n;j++){      //还原点
                node[j].c=cpy[j].c;
                node[j].in=cpy[j].in;
            }
            if(flag==0) ans=i;    //第三种情况（矛盾），记下此时的用到的关系对ans是第几对（用于输出）
            else if(flag&&ans!=-1) ans=i;//第一种情况（完成排序），记下此时的用到的关系对ans是第几对（用于输出）
        }
        p[n+1]='\0';
        if(flag&&ans==-1) printf("Sorted sequence cannot be determined.\n");
        else if(!flag) printf("Inconsistency found after %d relations.\n",ans);
        else if(flag) printf("Sorted sequence determined after %d relations: %s.\n",ans,p+1);
    }
}