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=;i<n;i++)
         {
         father[i]=i;head[i]=-;
         into[i]=;
         }
         number=n;
         point=n;
         side=m;
         count=;
         certain=true;
         conflict=false;
     }
     ~DEAL()
     {
         delete []edge;
         delete []father;
         delete []way;
         delete []head;
         delete []into;
     }
     void Input()
     {
         for(int i=;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=;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=;i<number;i++)
         {
             if(into[i]==&&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!=-;v=way[v].next)
             {
                 int u=way[v].to;
                 into[u]--;
                 if(!into[u])q.push(u);
             }
         }
     }
     void Output()
     {
         if(point>||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 ;
 }