Rank of Tetris 拓扑排序并查集

最新推荐文章于 2020-02-10 11:48:52 发布

lifelikes

最新推荐文章于 2020-02-10 11:48:52 发布

阅读量374

点赞数

分类专栏：栩的菜鸡笔记

本文链接：https://blog.csdn.net/lifelikes/article/details/75142825

版权

栩的菜鸡笔记专栏收录该内容

88 篇文章 0 订阅

订阅专栏

自从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

Sample Output

OK
CONFLICT
UNCERTAIN

拓扑排序，这是个很不错的题，把不确定顺序，冲突，正常顺序，都弄了一遍，搞懂每种情况有什么特点就好了。 by——qwb大佬。
太菜了太菜了，这题写了一下午。。。。。各种智商碾压。
想了四个小时，就那一个点没GET到，然后一直钻牛角尖。
解法：这道题难在有等于号，如果没有等于号这就是道裸的拓扑排序模板题。
既然等于号的情况难以判断，那我们就先化简一波问题，不考虑等于号，剩下的情况就很简单，很好处理。
然后我们反过头来单独考虑等于号。我们发现，有等于关系的点与外部所连的边都是共享的，这意味着，有等于关系的点对外部的点来说是同一个点，而又等于关系的点内部已经是有序的。因此，我们只需要吧有等于关系的点用并查集并在一起，在使用邻接链表添加边的时候全部用父节点代替，这样就很简单了。

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
using namespace std;
const int MAX=1e5+5;
int par[MAX];
int ranks[MAX];
int nodesize[MAX];
void init(int n)// 并查集初始化
{
    for(int i=0;i<=n;i++)
    {
        par[i]=i;
        ranks[i]=0;
        nodesize[i]=1;
    }
}
int finds(int x)
{
    if(par[x]==x)
    {
        return x;
    }
    else{
        return par[x]=finds(par[x]);
    }
}
void unite(int x,int y)
{
    x=finds(x);
    y=finds(y);
    if(x>y)
        swap(x,y);
    if(x==y) return ;
    par[y]=x;
    nodesize[x]+=nodesize[y];
}
class node
{
public:
    int x,y;
    node(int x,int y):x(x),y(y){}
    node(){}
};
int IN[22222];
int head[22222];
int tot;
void listinit()//初始化邻接链表
{
    tot=0;
    memset(head,-1,sizeof head);
    memset(IN,0,sizeof IN);
}
class sa
{
public:
    int u,v,next;
};
sa edge[55555];
void add(int u,int v)
{
    edge[tot].u=u;
    edge[tot].v=v;
    edge[tot].next=head[u];
    head[u]=tot;
    tot++;
    IN[v]++;
}
vector<node> V[3];
int vis[22222];
int sz;
int top_sort(int n)
{
    queue<int >Q;
    for(int i=0;i<n;i++)
    {
        int cnt=finds(i);
        if(IN[cnt]==0&&cnt==i)
            Q.push(cnt);
    }
    int flag=0;
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        u=finds(u);
        flag=max(flag,(int)Q.size());
        sz++;
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            IN[edge[i].v]--;
            if(IN[edge[i].v]==0)
                Q.push(edge[i].v);
        }
    }
    if(sz<n)
        return -1;
    else
        return flag;
}
int main(){
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        sz=0;
        memset(vis,0,sizeof vis);
        if(n==0&&m==0)
            break;
        listinit();
        init(n+2);
        for(int i=0;i<3;i++)
            V[i].clear();
        int len=n;
        for(int i=1;i<=m;i++) {
            int u,v;
            char cnt;
            cin>>u>>cnt>>v;
            if(cnt=='=')
            {
                V[0].push_back(node(u,v));
            }
            else if(cnt=='<')
            {
                V[1].push_back(node(u,v));
            }
            else
            {
                V[2].push_back(node(u,v));
            }
        }
        for(int i=0;i<V[0].size();i++)
        {
            sz++;//每当有点合并时，sz++.   理论上说这里是不对的， 如果两个点以及在一个并查集里了就错了，  不过过了测试数据我就懒得改了。
            unite(V[0][i].x,V[0][i].y);
        }
        int theflag=1;
        for(int i=0;i<V[1].size()&&theflag;i++)
        {
            add(finds(V[1][i].x),finds(V[1][i].y));
            if(finds(V[1][i].x)==finds(V[1][i].y))
            {
                theflag=0;
                break;
            }
            //cout<<V[1][i].x<<"->"<<V[1][i].y<<endl;
        }
        for(int i=0;i<V[2].size()&&theflag;i++)
        {
            add(finds(V[2][i].y),finds(V[2][i].x));
            if(finds(V[2][i].y)==finds(V[2][i].x))
            {
                theflag=0;
                break;
            }
            //cout<<V[2][i].y<<"->"<<V[2][i].x<<endl;
        }
        int sum=top_sort(n);
        //cout<<"sum:"<<sum<<endl;
        if(sum==-1||(!theflag)) printf("CONFLICT\n");
        else if(sum<=0) puts("OK");
        else puts("UNCERTAIN");
    }
    return 0;
}