ACM1811拓扑排序和并查集

/*
ACM1811 可以利用拓扑排序和并查集解决，主要方式是利用并查集在输入数据的时候将所有相等的点合并 
然后将处理完的数据统一按照一个符号方向连接成有向线段，利用的是邻接矩阵；接下来把每条边都进行履历 
如果出现conflict，那么就会在去除所有入度的时候无法找到新的零入度点，那么就会似的point无法减到零，
表示有conflict，如果出现uncertain，那么就会在一次寻找新的零入度点时能找到多个点，导致在队列中保存
多个数据 ； 
*/
#include<iostream>
#include<queue>
using namespace std;
class EDGE
{
    public: 
    int from,to;
    char sign;
};
class WAY
{
    public:
    int from,to,next; 
};
class DEAL
{
    public:
    DEAL(int n,int m)
    {
        edge=new EDGE[m];
        way=new WAY[m];
        father=new int[n];
        head=new int[n];
        into=new int[n];
        for(int i=0;i<n;i++)
        {
        father[i]=i;head[i]=-1;
        into[i]=0;
        }
        number=n;
        point=n;
        side=m;
        count=0;
        certain=true;
        conflict=false;
    }
    ~DEAL()
    {
        delete []edge;
        delete []father;
        delete []way;
        delete []head;
        delete []into;
    }
    void Input()
    {
        for(int i=0;i<side;i++)
        {
            cin>>edge[i].from>>edge[i].sign>>edge[i].to;
            if(edge[i].sign=='=')
            {
            int fa=FindFather(edge[i].from);
            int fb=FindFather(edge[i].to);
                Union(fa,fb);
                point--;
            }
        }
    }
    void Preprocess()
    {
        for(int i=0;i<side;i++)
        {
            if(edge[i].sign=='=')continue;
            int fa=FindFather(edge[i].from);
            int fb=FindFather(edge[i].to);
            if(fa==fb)conflict=true;
            if(edge[i].sign=='<')
                Merge(fb,fa);
            else if(edge[i].sign=='>')
                Merge(fa,fb);
        }
    }
    void Toposort()
    {
        for(int i=0;i<number;i++)
        {
            if(into[i]==0&&father[i]==i)//是头节点 
                q.push(i);
        }
        while(!q.empty())
        {
            int l=q.front();
            q.pop();
            point--;
            if(!q.empty())certain=false;
            int v;
            for(v=head[l];v!=-1;v=way[v].next)
            {
                int u=way[v].to;
                into[u]--;
                if(!into[u])q.push(u);
            }
        }
    }
    void Output()
    {
        if(point>0||conflict)
            cout<<"CONFLICT"<<endl;
        else if(!certain)cout<<"UNCERTAIN"<<endl;
        else cout<<"OK"<<endl;
    }
    int FindFather(int x)
    {
        if(x==father[x])return x;
        return father[x]=FindFather(father[x]);
    }
    void Union(int x,int y)
    {
        if(x!=y)father[y]=x;//后面跟着前面 
    }
    void Merge(int x,int y)
    {
        way[count].from=x;
        way[count].to=y;
        way[count].next=head[x];
        into[y]++;
        head[x]=count++;
    }
    private:
        queue<int>q;
        int number,side,point,count;
        EDGE *edge;
        WAY *way;
        int *father,*head,*into;
        bool certain,conflict;
};
int n,m;
int main()
{
    while(cin>>n>>m)
    {
        DEAL ob(n,m);
        ob.Input();
        ob.Preprocess();
        ob.Toposort();
        ob.Output();
    }
    return 0;
}