Rank of Tetris HDU--1881

Rank of Tetris

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 4031    Accepted Submission(s): 1133

Problem Description

自从Lele开发了Rating系统，他的Tetris事业更是如虎添翼，不久他遍把这个游戏推向了全球。

为了更好的符合那些爱好者的喜好，Lele又想了一个新点子：他将制作一个全球Tetris高手排行榜，定时更新，名堂要比福布斯富豪榜还响。关于如何排名，这个不用说都知道是根据Rating从高到低来排，如果两个人具有相同的Rating，那就按这几个人的RP从高到低来排。

终于，Lele要开始行动了，对N个人进行排名。为了方便起见，每个人都已经被编号，分别从0到N-1,并且编号越大，RP就越高。
同时Lele从狗仔队里取得一些（M个）关于Rating的信息。这些信息可能有三种情况，分别是"A > B","A = B","A < B"，分别表示A的Rating高于B,等于B,小于B。

现在Lele并不是让你来帮他制作这个高手榜，他只是想知道，根据这些信息是否能够确定出这个高手榜，是的话就输出"OK"。否则就请你判断出错的原因，到底是因为信息不完全（输出"UNCERTAIN"），还是因为这些信息中包含冲突（输出"CONFLICT"）。
注意，如果信息中同时包含冲突且信息不完全，就输出"CONFLICT"。

 

Input

本题目包含多组测试，请处理到文件结束。
每组测试第一行包含两个整数N,M(0<=N<=10000,0<=M<=20000),分别表示要排名的人数以及得到的关系数。
接下来有M行，分别表示这些关系

 

Output

对于每组测试，在一行里按题目要求输出

 

Sample Input

3 3

0 > 1

1 < 2

0 > 2

4 4

1 = 2

1 > 3

2 > 0

0 > 1

3 3

1 > 0

1 > 2

2 < 1

 

Sample Output

OK

CONFLICT

UNCERTAIN

思路：

此题花了我好长时间，一开始以为rating相同的点就直接比较rp然后建图，后来想想不对，因为这样发现不了冲突。后来一想对于rating相同的点可以不用排序，因为对于这些点，他们的rp必然不相同，也就是说在这些点的内部必然存在唯一的且合理的排序，因此只需将要将这些点合并成一个点即可，需要用到并查集的知识。

把所有点按上述方法处理后就会得到一些点（暂且称为“有效点”），对于这些有效点再进行拓扑排序即可。

冲突情形：到最后存在环，或者出现a > b,b > c 且 c >a；

不确定情形：同一层中不止一个点入度为0；

确定情形：除以上两种情形;

AC代码:

 #include<stdio.h>
 #include<string.h>
 typedef struct
 {
     int to;
     int next;
 }EdgeNode;
 int cnt;
 char str[];
 EdgeNode Edge[];
 int father[],depth[];
 int L[],M[],R[];
 int head[],indegree[];
 int vis[],node[],temp[];
 void init(int n)
 {
     int i;
     cnt = ;
     memset(vis,,sizeof(vis));
     memset(head,-,sizeof(head));
     memset(indegree,,sizeof(indegree));
     for(i = ;i < n;i ++)
     {
         father[i] = i;
         depth[i] = ;
     }
 }
 
 int find(int x)
 {
     if(x == father[x])
         return x;
     return father[x] = find(father[x]);
 }
 
 void uint(int x,int y)
 {
     x = find(x);
     y = find(y);
     if(x == y)
         return ;
     if(depth[x] < depth[y])
         father[x] = y;
     else
     {
         if(depth[x] > depth[y])
             father[y] = x;
         else
         {
             father[x] = y;
             depth[y]++;
         }
     }
     return ;
 }
 
 void add_edge(int n,int m)
 {
     Edge[cnt].to = m;
     Edge[cnt].next = head[n];
     head[n] = cnt++;
 }
 
 int main(void)
 {
     int a,b,n,m,i,j,k;
     int sum,flag_U,flag_C;
     while(~scanf("%d %d",&n,&m))
     {
         init(n);
         flag_U = flag_C = ;
         for(i = ;i <= m;i ++)
         {
             scanf("%d %c %d",&L[i],&M[i],&R[i]);
             if(M[i] == '=')
             {
                 uint(L[i],R[i]);
             }
         }
         for(i = ;i <= m;i ++)
         {
             if(M[i] == '=')
                 continue ;
             a = find(L[i]);
             b = find(R[i]);
             if(a == b)
             {
                 flag_C = ;
                 break ;
             }
             else
             {
                 if(M[i] == '>')
                 {
                     add_edge(b+,a+);
                     indegree[a+]++;
                 }
                 else
                 {
                     add_edge(a+,b+);
                     indegree[b+]++;
                 }
             }
         }
         for(i = ;i <= n;i ++)
         {
             sum = ;
             for(j = ;j <= n;j ++)
             {
                 if(indegree[j] ==  && vis[j] ==  && father[j-] == j-)
                     temp[sum++] = j;
             }
             if(sum > )
                 flag_U = ;
             for(j = ;j < sum;j ++)
             {
                 vis[temp[j]] = ;
                 for(k = head[temp[j]];k != -;k = Edge[k].next)
                 {
                     if(!vis[Edge[k].to])
                         indegree[Edge[k].to]--;
                 }
             }
         }
         for(i = ;i <= n;i ++)
         {
             if(indegree[i] && father[i-] == i-)
             {
                 flag_C = ;
                 break ;
             }
         }
         if(!(flag_C+flag_U))
             printf("OK\n");
         if(flag_C)
             printf("CONFLICT\n");
         if(flag_U && !flag_C)
             printf("UNCERTAIN\n");
     }
     return ;
 }