hdu 1811 Rank of Tetris（拓扑，并查集）

题意：略

分析：排序先按rating，若相同，则按rp。考虑到每个人的rp均不同，所以rating相同的人必然可以排序。那么只需要考虑rating不同的集合了。

　　  大小关系可以用有向边表示，而大小关系的传递可以用拓扑排序来呈现。

　　  接着就要分析，三种结果对应的情况了。

　　  很明显，ok要求拓扑出来的必须是一条链，一旦有分支，分支处的两个（或多个）点的大小关系就不明确，也就是条件不足=>uncertain。

　　  而矛盾conflict有两种情况：1、更改关系0=1,0>1；2、自相矛盾，即成环，0>1,0<1。

注意：在条件不足和矛盾同时发生时，要求输出的是矛盾conflict。

　　  这里要注意，拓扑排序是可以判环的：只要完成拓扑后，发现还有点没有加入队列，那么就说明他们之间成环。若不成环，必然可以把所有点加入队列。

　　  学习了vector的find函数

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;

const int MAXN=11111;

struct Edge{
    int x,y;
    char op;
}edge[MAXN<<1];

vector<int>G[MAXN];
queue<int>q;
int in[MAXN],f[MAXN];
int inq[MAXN];

void init(int n)
{
    for(int i=0;i<n;i++)
        f[i]=i;

    memset(in,0,sizeof(in));

    for(int i=0;i<n;i++)
        G[i].clear();
}

int Find(int x)
{
    return f[x]==x?x:f[x]=Find(f[x]);
}

int top(int n)
{
    int flog=1;
    while(!q.empty())
        q.pop();
    memset(inq,0,sizeof(inq));//判入队

    for(int i=0;i<n;i++)
    {
        int x=Find(i);
        if(x!=i)//忽略所有集合中除根以外的点
            inq[i]=1;
        else if(in[x]==0){
            q.push(x);
            inq[x]=1;
        }
    }
    if(q.empty())//队空，成环，冲突
        return -1;
    while(!q.empty())
    {
        if(q.size()>=2)//多叉，不分先后，条件不足
            flog=0;

        int u=q.front();q.pop();
        int sz=G[u].size();
        for(int i=0;i<sz;i++)
        {
            int v=G[u][i];
            in[v]--;
            if(in[v]==0){
                if(inq[v])//成环，冲突
                    return -1;
                else {
                    q.push(v);
                    inq[v]=1;
                }
            }
        }
    }
    for(int i=0;i<n;i++)
        if(!inq[i])//不能全部拓扑，成环，冲突
            return -1;
    return flog;
}

int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        int flog=1;
        init(n);
        for(int i=0;i<m;i++)
        {
            scanf("%d %c %d",&edge[i].x,&edge[i].op,&edge[i].y);
            if(edge[i].op=='='){
                int a=Find(edge[i].x);
                int b=Find(edge[i].y);
                f[a]=b;
            }
        }
        for(int i=0;i<m;i++)
        {
            if(edge[i].op=='=')
                continue;

            int a=Find(edge[i].x);//所有处理都是对集合的根做操作
            int b=Find(edge[i].y);
            if(a==b)
                flog=-1;
            if(flog==-1)
                break;

            if(edge[i].op=='<'){
                if(find(G[b].begin(),G[b].end(),a)==G[b].end()){//去重，长知识了
                    G[b].push_back(a);
                    in[a]++;
                }
            }else{
                if(find(G[a].begin(),G[a].end(),b)==G[a].end()){
                    G[a].push_back(b);
                    in[b]++;
                }
            }
        }
        if(flog==-1){
            printf("CONFLICT\n");
            continue;
        }
        flog=top(n);
        if(flog==-1)
            printf("CONFLICT\n");
        else if(flog==0)
            printf("UNCERTAIN\n");
        else
            printf("OK\n");
    }
    return 0;
}
/*
4 3
0 < 1
1 < 2
2 < 0

4 3
0 > 1
1 < 2
0 > 2

4 3
1 = 2
0 < 1
3 > 2

4 3
1 = 2
0 < 1
0 > 2

3 3
1 = 2
2 = 0
1 > 2

3 1
1 < 2
*/