HDU 1811

http://acm.hdu.edu.cn/showproblem.php?pid=1811

中文码题

对于等号的情况，用并查集合并（因为编号不同一定可以分出先后）

然后判断能否构成拓扑排序，以及拓扑排序是不是唯一的

题不难，考验代码能力，能1A证明手感还不错

#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <algorithm>
#include <queue>
#include <cmath>
#include <stack>
#include <set>

using namespace std;

int vis[10005],head[10005],cnt,fa[10005],st[10005];

struct p{
    int a,b;
    char op[5];
}kk[10005];

struct node{
    int s,t,nxt;
}e[1000005];

void add(int s,int t){
    e[cnt].s=s;e[cnt].t=t;e[cnt].nxt=head[s];head[s]=cnt++;
}

void INIT(){
    cnt=0;
    memset(head,-1,sizeof(head));
}

int find(int x){
    return fa[x]==x?x:fa[x]=find(fa[x]);
}


int dfs(int u){
    vis[u]=-1;
    for(int i=head[u];i!=-1;i=e[i].nxt){
        int v=e[i].t;
        if(vis[v]<0)return 0;
        else if(!vis[v] && !dfs(v))return 0;
    }
    vis[u]=1;
    return 1;
}

int OK(int n){
    for(int i=0;i<n;i++){
        if(!vis[i] && !st[i] && !dfs(i))return 0;
    }
    return 1;
}

int IN[10005];

int main(){
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        INIT();
        for(int i=0;i<n;i++)fa[i]=i;
        memset(IN,0,sizeof(IN));
        memset(st,0,sizeof(st));
        int flag=1;
        for(int i=0;i<m;i++){
            scanf("%d%s%d",&kk[i].a,kk[i].op,&kk[i].b);
            if(kk[i].op[0]=='='){
                int pa=find(kk[i].a);
                int pb=find(kk[i].b);
                if(pa!=pb){
                    fa[pa]=pb;
                    st[pa]=1;
                }
            }
            else{
                int pa=find(kk[i].a);
                int pb=find(kk[i].b);    
                if(pa==pb)flag=0;
            }
        }
        if(!flag)puts("CONFLICT");//所给信息矛盾 
        else{
            for(int i=0;i<m;i++){
                if(kk[i].op[0]=='>'){
                    add(find(kk[i].a),find(kk[i].b));
                    IN[find(kk[i].b)]++;
                }
                else if(kk[i].op[0]=='<'){
                    add(find(kk[i].b),find(kk[i].a));
                    IN[find(kk[i].a)]++;
                }
            }
            memset(vis,0,sizeof(vis));
            if(!OK(n))puts("CONFLICT");//有环 
            else{
                queue <int> q;
                for(int i=0;i<n;i++){
                    if(!st[i] && !IN[i])
                        q.push(i);
                }
                int flag=1;
                while(!q.empty()){
                    if(q.size()>1){
                        flag=0;
                        break;
                    }
                    int u=q.front();
                    q.pop();
                    for(int i=head[u];i!=-1;i=e[i].nxt){
                        int v=e[i].t;
                        IN[v]--;
                        if(!IN[v])q.push(v);
                    }
                }
                if(!flag)puts("UNCERTAIN");//拓扑结构一层多于一个点，有多种情况 
                else puts("OK");
            }
        }
    }
    return 0;
}