hdu 1811 并查集+拓扑排序+细心-CSDN博客

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

CONFLICT

UNCERTAIN

先处理等于号，所有等于的压缩成一个点！

设A>B或B<A,直接在A与B之间加一条有向边即可.

我们把所有具有=关系的点都聚合成1点(合并为一个连通分量,且只用该分量的根节点代替分量中的所有点).然后我们只处理>或<关系(添加两个分量根之间的有向边).然后我们只需要判断这个缩减的图是否能全排序或拓扑排序或冲突即可.

未ac代码完全找不到错误，试了很多样例全过！

#include <bits/stdc++.h>
using namespace std;
const int maxn=2e5+5;
int par[maxn];
int head[maxn];
int ind[maxn];
int cnt;	
int n,m;
struct node{
	//int w;  //权值   不需要 
	int e;
	int next; //next[i]表示与第i条边同起点的上一条边的储存位置
}edge[maxn];    //链式前向星 
void add(int u,int v){ //,int w
	//edge[cnt].w=w;
	edge[cnt].e=v;    //edge[i]表示第i条边的终点 
	edge[cnt].next=head[u]; //head[i]表示以i为起点的最后一条边的储存位置 
	head[u]=cnt++;
}
void init(){
	for(int i=0;i<maxn;i++){
		par[i]=i;
		head[i]=-1;
		ind[i]=0;
	}
	cnt=0;
}
int find( int x){
	if( x!=par[x] )
		par[x]=find( par[x]) ;
	return par[x];
}
void Union(int x,int y){
	int xx=find(x);
	int yy=find(y);
	if(xx!=yy){
		par[y]=x;
	}
}
int toop(){
	queue<int> q;
	int ans=0; //跟节点数量 
	int cnt=0; //出对数量 
	bool all_order=true;  //能否全排列 
	for(int i=0;i<n;i++){
		if(find(i)==i){
			ans++;
			if( ind [i]==0 ){
				q.push(i);
//				printf("i:%d\n",i);
			} 
		}
		
	}
	while(!q.empty()){
		if(q.size()>1) all_order=false;
		int u=q.front();q.pop();
		cnt++;
		for(int k = head[ u ] ; k != -1 ; k = edge[k].next){
			int v=edge[k].e;
			ind[ find(v) ] -- ;
			if(ind[ find(v) ] == 0){
				q.push( find(v) );
			}
		}
	}
//	printf("ans %d cnt %d\n",ans,cnt);
	if(cnt<ans)  return -1; //冲突 
	if(all_order)  return 1;  //可以全排列  不会一次入队2个 
	return  0;  //可以toop
}
int main(){
	while(~scanf("%d%d",&n,&m)){
		init();
		int a[maxn],c[maxn];
		char b[maxn];
		for(int i=0;i<m;i++){
			scanf("%d %c %d",&a[i],&b[i],&c[i]);
			if(b[i]=='=') Union(a[i],c[i]);
			//所有等于号 压缩成一个点处理 
		}
		int f=0; //保存结果状态,-1表冲突,0表拓扑排序,1表全排序
		for(int i=0;i<m;i++){
			if(b[i]!='=' &&find(a[i])==find(c[i] )) {
				f=-1;break; //冲突 
			} 
			if(b[i]=='>') {
				add ( find(a[i]) ,find (c[i]));
				ind[ find(c[i]) ]++;
			}
			else if(b[i]=='<' ) {
				add( find(c[i]) ,find (a[i]));
				ind[ find(a[i])] ++;
			}
		}
		
//		for(int i=0;i<n;i++){
//			for(int j=head[i];j!=-1;j=edge[j].next){
//				printf("%d->%d\n",i,edge[j].e);
//			}
//		}
//		int g=0;
//		for(int i=0;i<n;i++)
//			if(par[i]==i)  g++; 
		if(f==0) f=toop(); 
		if( f==-1) puts("CONFLICT");
		else if(f==0) puts("UNCERTAIN");
		else if(f==1 )  puts("OK");
	}
	return 0;
}

大佬ac代码：

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int maxn=10000+10;
const int maxm=20000+10;
int n,m;
int fa[maxn];
int find(int i)
{
    if(fa[i]==-1) return i;
    return fa[i]=find(fa[i]);
}
int in[maxn],head[maxn];
struct Edge
{
    int to,next;
}edges[maxm];   //边从0保存
int tot;        //计数边总数
void add_edge(int from,int to)
{
    edges[tot]=(Edge){to,head[from]};
    head[from]=tot++;
    in[to]++;
}
int topo()
{
    queue<int> Q;
    int fa_num=0;   //连通分量根数目
    int cnt=0;      //入度为0且从Q出队列的点数
    bool all_order=true;//是否可全排序标志
    for(int i=0;i<n;i++)if(find(i)==i)
    {
        fa_num++;
        if(in[i]==0) Q.push(i);
    }
    while(!Q.empty())
    {
        if(Q.size()>1) all_order=false;
        int u=Q.front(); Q.pop();
        cnt++;
        for(int e=head[u];e!=-1;e=edges[e].next)
        {
            int v=edges[e].to;
            if(--in[find(v)]==0)
                Q.push(find(v));
        }
    }
    if(cnt<fa_num) return -1;   //冲突
    if(all_order) return 1;     //可全排序
    return 0;                   //可拓扑排序
}
char str[maxm][5];
int a[maxm],b[maxm];
int main()
{
    while(scanf("%d%d%*c",&n,&m)==2)
    {
 
        memset(head,-1,sizeof(head));
        memset(fa,-1,sizeof(fa));
        memset(in,0,sizeof(in));
        tot=0;
        int ans=0;              //保存结果状态,-1表冲突,0表拓扑排序,1表全排序
        for(int i=0;i<m;i++)    //读取关系,合并连通分量
        {
            scanf("%d%s%d",&a[i],str[i],&b[i]);
            if(str[i][0]=='=')
            {
                int u=a[i], v=b[i];
                u=find(u), v=find(v);
                if(u!=v) fa[u]=v;
            }
        }
        for(int i=0;i<m;i++)    //添加有向边,且判断连通分量中是否冲突
        {
            int u=a[i], v=b[i];
            if(find(u)==find(v) && str[i][0]!='=')
            {
                ans=-1;         //冲突
                break;
            }
            if(str[i][0]=='<')      add_edge(find(v),find(u));
            else if(str[i][0]=='>') add_edge(find(u),find(v));
        }
        if(ans==0) ans=topo();
        if(ans==-1) printf("CONFLICT\n");
        else if(ans==0) printf("UNCERTAIN\n");
        else if(ans==1) printf("OK\n");
    }
    return 0;
}

转载于:https://www.cnblogs.com/lyj1/p/11378043.html