集合归类

最新推荐文章于 2022-04-07 17:27:47 发布
最新推荐文章于 2022-04-07 17:27:47 发布
阅读量348 收藏
点赞数
分类专栏： 编程题 文章标签： 并查集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhagoodwell/article/details/78700853
版权

题目：对于集合S={1,2,3,4,5,6,7,8,9,10,11,12,13}:依次读入若干等价对1三5，2三3……等价对中的数属于同一个集合，现在需要编程识别等价对1将集合S划分成几个子集和

输出：

3   //3个等价对

1  5‘

2  3

5  8

输出:

1 5 8

2 3

这道题可以用图的遍历 输出 但是如果集合S的数量非常庞大 用图就会内存不足

省内存的话用并查集即可

# include <stdio.h>
# define N 100000001
int p[N],y;
int C[N];
int tree[2*N],num;
void Dsort(int *tree,int n);
int find(int x);
void Link(int x,int y);
int main()
{
    int i,j,k,l,m,n;
    //freopen("AAA.txt","r",stdin);
    while(~scanf("%d",&n))
    {
        for(i=0; i<n; i++)
        {
            scanf("%d%d",&j,&k);
            Link(j,k);
        }
        Dsort(tree,num);
        for(i=m=k=0; i<num; i++)
            if(p[tree[i]])
            {
                for(j=i,l=find(tree[i]); j<num; j++)
                    if(p[tree[j]]&&find(tree[j])==l)
                    {
                        C[k++]=tree[j];
                        printf("%d ",tree[j]);
                    }
                while(m<k)p[C[m++]]=0;
                C[k++]=0;
                printf("\n");
            }
        num=0;
    }
    return 0;
}
int find(int x)
{
    y=x;
    if(p[x])while(x!=p[x]) x=p[x];
    else tree[num++]=x;
    return p[y]=x;
}
void Link(int x,int y)
{
    p[find(x)]=find(y);
}
void Dsort(int *tree,int n)
{
    int i,j=1,L,R;
    tree--;
    while((i=++j)<=n)
    {
        R=tree[i];
        while(i>1)
        {
            L=(i>>1);
            if(tree[L]>=R) break;
            tree[i]=tree[L];
            i=L;
        }
        tree[i]=R;
    }
    while(n)
    {
        R=tree[n];
        tree[n--]=tree[1];
        i=1;
        L=2;
        while(L<=n)
        {
            L+=L<n&&tree[L+1]>tree[L];
            if(tree[L]<=R) break;
            tree[i]=tree[L];
            i=L;
            L<<=1;
        }
        tree[i]=R;
    }
}


# include <stdio.h> //用优先队列 时间开销小     
# define N 1000001      
void insert(int Tree[],int X);//向堆中插入值 S[WEI]     
int Delmin(int Tree[]);       //删除堆头-并返回堆头   
int find(int x);  
void Link(int x,int y);  
int tree[N+1];  //堆    
int p[N],Q[N],C[2*N];     
int main(){  
    int i,j,k,l,m,n;   
    scanf("%d",&n);  
    for(i=0;i<n;i++)  
    {  
        scanf("%d%d",&j,&k);   
        if(find(j)!=find(k))  
            Link(j,k);   
    }  
    n=0;  
    while(tree[0])Q[n++]=Delmin(tree);  
    for(i=m=k=0;i<n;i++)  
        if(p[Q[i]])  
        {  
            for(j=i,l=find(Q[i]);j<n;j++)  
                if(p[Q[j]]&&find(Q[j])==l)  
                {  
                    C[k++]=Q[j];  
                    printf("%d ",Q[j]);  
                }  
                while(m<k)p[C[m++]]=0;  
                k++;  
                printf("\n");  
        }  
        return 0;  
}  
void insert(int Tree[],int X)//向最小堆中插入X   
{        
    int par,i=++Tree[0];            //插入X 后 Tree[0]+1        
    while(i>1)                      //直到i不是根节点        
    {        
        par=(i>>1);                 //父节点为par        
        if(Tree[par]<=X) break;     //将<=改为>=即改为最大堆了    
        Tree[i]=Tree[par];          //否则调整堆 即位置上移        
        i=par;        
    }        
    Tree[i]=X;                      //插入新节点        
}        
int Delmin(int Tree[])        
{        
    int i=1,L=2,root=Tree[1],X=Tree[Tree[0]--];       
    while(L<=Tree[0])        
    {            
        L+=L<Tree[0]&&Tree[L+1]<Tree[L];  
        if(Tree[L]>=X) break;  
        Tree[i]=Tree[L];       
        i=L;    L=i<<1;   
    }        
    Tree[i]=X;    
    return  root;        
}  
int find(int x)  
{  
    if(!p[x]) 
	{
	   p[x]=x;  
	   insert(tree,x);//进堆
	}
    while(x!=p[x]) x=p[x];  
    return x;  
}  
void Link(int x,int y)  
{  
    int fx=0,fy=0;  
    if(!p[x]) p[x]=x;  
    if(!p[y]) p[y]=y;  
    while(x!=p[x]&&++fx) x=p[x];  
    while(y!=p[y]&&++fy) y=p[y];  
    if(x==y)return ;  
    if(fx<fy)p[x]=y;  
    else    p[y]=x;  
}


、、、、、、、、、、、、、

# include <stdio.h> //用优先队列 时间开销小   
# define N 1000001    
void insert(int Tree[],int X);//向堆中插入值 S[WEI]   
int Delmin(int Tree[]);       //删除堆头-并返回堆头 
int find(int x);
void Link(int x,int y);
int tree[N+1];  //堆  
int p[N],Q[N],C[2*N];   
int main(){
    int i,j,k,l,m,n;
    //freopen("DDD.txt","r",stdin);
    scanf("%d",&n);
    for(i=0;i<n;i++)
	{
       	scanf("%d%d",&j,&k);
		if(!p[j])insert(tree,j);
		if(!p[k])insert(tree,k);
       	if(find(j)!=find(k))
			Link(j,k); 
	}
	n=k=0;
	while(tree[0])
		Q[n++]=Delmin(tree);
    for(i=m=k=0;i<n;i++)
		if(p[Q[i]])
		{
			for(j=i,l=find(Q[i]);j<n;j++)
				if(p[Q[j]]&&find(Q[j])==l)
				{
					C[k++]=Q[j];
					printf("%d ",Q[j]);
				}
				while(m<k)p[C[m++]]=0;
				k++;
				printf("\n");
		}
		return 0;
}
void insert(int Tree[],int X)//向最小堆中插入X 
{      
    int par,i=++Tree[0];            //插入X 后 Tree[0]+1      
    while(i>1)                      //直到i不是根节点      
    {      
        par=(i>>1);                 //父节点为par      
        if(Tree[par]<=X) break;     //将<=改为>=即改为最大堆了  
        Tree[i]=Tree[par];          //否则调整堆 即位置上移      
        i=par;      
    }      
    Tree[i]=X;                      //插入新节点      
}      
int Delmin(int Tree[])      
{      
	int i=1,L=2,root=Tree[1],X=Tree[Tree[0]--];     
	while(L<=Tree[0])      
	{          
		L+=L<Tree[0]&&Tree[L+1]<Tree[L];
		if(Tree[L]>=X) break;
		Tree[i]=Tree[L];     
		i=L;	L=i<<1; 
	}      
	Tree[i]=X;  
	return  root;      
}
int find(int x)
{
    if(!p[x]) p[x]=x;
    while(x!=p[x])x=p[x];
    return x;
}
void Link(int x,int y)
{
    int fx=0,fy=0;
    if(!p[x]) p[x]=x;
    if(!p[y]) p[y]=y;
    while(x!=p[x]&&++fx) x=p[x];
    while(y!=p[y]&&++fy) y=p[y];
    if(x==y)return ;
    if(fx<fy)p[x]=y;
    else	p[y]=x;
}


--------------------------------

//

/*
EG:
15
1 99999999
3 2
5 2
8 5
9 6
7 6
4 10
10 6
88 4
88 99999999
2 99999999
8888 9999
9999 88888
777 88888
999 777

*/
#include<stdio.h>  
#define N 100000000
# define max(a,b) (a)>(b)?(a):(b)   
int p[N];  
int Q[2*N],C[N];
int find(int x)
{
    if(!p[x]) p[x]=x;
    while(x!=p[x])x=p[x];
    return x;
}
void Link(int x,int y)
{
    int fx=0,fy=0;
    if(!p[x]) p[x]=x;
    if(!p[y]) p[y]=y;
    while(x!=p[x]&&++fx)x=p[x];
    while(y!=p[y]&&++fy)y=p[y];
    if(x==y)return ;
    if(fx<fy) p[x]=y;
    else p[y]=x;
}
void change(int *a,int *b)//交换函数 交换a b的值  
{  
    int c=*a;  
    *a=*b;  
    *b=c;  
}  
void Qsort(int A[],int L,int R)//快速排序 升序   
{  
    int i=L,j=R,T=A[L]; //T为基准数  
    if(L>R)  return;  
    while(i!=j) //当数组左右两边没相遇  
    {  
        while(A[j]>=T&&i<j)j--;  //从右向左找  改为while(A[j]<=T&&i<j)  
        while(A[i]<=T&&i<j)i++; //从左向右找   改为while(A[i]>=T&&i<j) 这两处 改完即为降序   
        if(i<j)change(&A[i],&A[j]); //交换两数  
    }  
	if(L!=i)change(&A[L],&A[i]);       //基准数归位  
    Qsort(A,L,i-1);         //递归左  
    Qsort(A,i+1,R);         //递归右  
}  
int main(){
    int n,i,j,k,m;
    //freopen("DDD.txt","r",stdin);
    scanf("%d",&n);
    for(i=0;i<n;i++)
	{
		j=i<<1;
       	scanf("%d%d",&Q[j],&Q[j+1]);
       	if(find(Q[j])!=find(Q[j+1]))
			Link(Q[j],Q[j+1]); 
	}
	n<<=1;
	Qsort(Q,0,n-1);
    for(i=j=k=0;j<n;i=j)
	{
		Q[k++]=Q[i];
		while(j<n&&Q[i]==Q[++j]);
	}//筛掉重复的值得到k个不同的值Q共k个
	n=k;
    for(i=m=k=0;i<n;i++)
		if(p[Q[i]])
		{
			for(j=i;j<n;j++)
				if(p[Q[j]]&&find(Q[i])==find(Q[j]))
					C[k++]=Q[j];
				while(m<k)p[C[m++]]=0;
				k++;
		}
	for(i=0;i<k;i++)
	{
		if(C[i])printf("%d ",C[i]);
		else printf("\n");
	}
	return 0;
}
//快排+筛选


______________________________________

/*
EG:
15
1 99999999
3 2
5 2
8 5
9 6
7 6
4 10
10 6
88 4
88 99999999
2 99999999
8888 9999
9999 88888
777 88888
999 777

*/
#include<stdio.h>  
#define N 100000000
# define max(a,b) (a)>(b)?(a):(b)   
int p[N],M,C[N];  
int find(int x)
{
    if(!p[x]) p[x]=x;
    while(x!=p[x])x=p[x];
    return x;
}
void Link(int x,int y)
{
    int fx=0,fy=0;
    if(!p[x]) p[x]=x;
    if(!p[y]) p[y]=y;
    while(x!=p[x]&&++fx)x=p[x];
    while(y!=p[y]&&++fy)y=p[y];
    if(x==y)return ;
    if(fx<fy) p[x]=y;
    else p[y]=x;
}
int main(){
    int n,x,y,i,j,k,m;
    //freopen("DDD.txt","r",stdin);
    scanf("%d",&n);
    for(i=0;i<n;i++)
	{
       	scanf("%d%d",&x,&y);
       	if(find(x)!=find(y))
			Link(x,y); 
       	M=max(M,max(x,y));
	   }
    for(i=1,m=k=0;i<=M;i++)
	{
		if(p[i])
		{
			C[k++]=i;
			for(j=1;j<=M;j++)
				if(p[j]&&i!=j&&find(i)==find(j))
					C[k++]=j;
			while(m<k)p[C[m++]]=0;
			k++;
		}
	}
	for(i=0;i<k;i++)
	{
		if(C[i])printf("%d ",C[i]);
	    else printf("\n");
	}
	return 0;
}



zhagoodwell
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA的集合归类
qq_45337117的博客
07-05 550
集合可分为三种：List，Set，Map。 一.List List是有序存储的。 List的创建: List<类型> list=new ArrayList<>() list.add(a) 将a存入list集合中。 list.remove(i)将集合中索引i的数据删除。 List有3种遍历方法： package com.zhongruan.example; import ja...
集合的归纳
qq_45897136的博客
06-30 382
一方面，面向对象语言对事务的体现都是以对象的形式，为了方便多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象具有一些弊端，而Java集合就像一种容器，可以动态的把多个对象的引用存入集合中...
【python】字符串基础练习题（3）
CHOITAKWAI的博客
04-07 802
【python】字符串基础练习题（3）
编写程序，已知字符串s = ‘AbcDeFGhIJ‘，请计算该字符串中小写字母的数量。
CSND_DIR的博客
01-02 1万+
s = 'AbcDeFGhIJ' num = 0 # 统计英文字母个数 for i in range(len(s)): # 利用字符在ASCII码中的位置逐个统计 if "a" <= s[i] <= "z": num += 1 print("小写字母的个数为:%d" % num) # 打印小写字母个数
【集合论】等价类 ( 等价类概念 | 等价类示例 | 等价类性质 | 商集 | 商集示例 )★
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
10-10 3万+
一、等价类 、 二、等价类示例 、 三、等价类性质 、 四、商集 、 五、商集示例 1 、 六、商集示例 2 、 七、商集示例 3 、
集合栈
Bryan要加油
03-01 635
题目描述请实现一种数据结构SetOfStacks，由多个栈组成，其中每个栈的大小为size，当前一个栈填满时，新建一个栈。该数据结构应支持与普通栈相同的push和pop操作。 给定一个操作序列int[][2] ope(C++为vector解答　　算是考细节的题吧，认真些。 　　class SetOfStacks { public: vector<vector<int> > setOfSt
web标准资料集合归类.pdf
01-14
【Web标准资料集合归类.pdf】是一份关于网络文档，特别是关于UI设计的详细资料。UI，即用户界面，是用户与软件交互的桥梁，它包括界面设计、人机交互和用户行为的研究。UI设计的核心目标是提升软件的用户体验，使其...
初中数学优秀教案大集合归类.pdf
11-13
《初中数学优秀教案大集合归类》是一份针对初中生的数学教学资料，主要涵盖了二元一次方程的相关知识。二元一次方程是含有两个未知数的方程，其中每个未知数的次数都为1。教学目标不仅要求学生理解和掌握二元一次...
子集合问题matlab
09-17
这个问题可以被归类为一个动态规划或回溯法的问题，因为它具有重叠子问题和最优子结构的特性。 **动态规划解决方案：** 动态规划是一种自底向上的方法，通过构建一个二维数组dp来存储所有可能子集和的信息。dp[i][j...
集合与函数复习讲义归类.pdf
11-15
集合具有三个基本特性：确定性（每个元素要么属于集合，要么不属于集合）、无序性（集合中元素的排列顺序不影响集合本身）和互异性（集合中没有重复的元素）。例如，在2007年全国1高考题中，通过分析集合的特性可以...
Oracle错误代码集合[归类].pdf
10-12
Oracle错误代码是数据库系统在运行过程中遇到问题时给出的具体指示，帮助开发者和DBA诊断和解决故障。以下是一些常见的Oracle错误代码及其含义的详细解释： 1. ORA-17001: 这是一个内部错误，通常表示Oracle遇到了...
运动会分数统计(数据结构课程设计)
热门推荐
zhagoodwell查的博客
12-08 3万+
参加运动会有n个学校，学校编号为1……n。比赛分成m个男子项目，和w个女子项目。项目编号为男子1……m，女子m+1……m+w。不同的项目取前五名或前三名积分；取前五名的积分分别为：7、5、3、2、1，前三名的积分分别为：5、3、2；哪些取前五名或前三名由学生自己设定。（m<=20,n<=20） 经过两天的艰苦奋战，我终于完成了这项工作，排错和输入等方面做了很多改进，用户输入的时候会有...
内部排序算法的实现与比较-数据结构课程设计
zhagoodwell查的博客
11-06 1万+
内部排序算法的实现与比较 1） 问题描述 在教科书中，各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。试通过随机数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。 2）基本要求 (1) 对常用的内部排序算法进行比较：直接插入排序、简单选择排序、冒泡排序、快速排序、希尔排序、归并排序。 (2) 利用随机函数产生N（N=30000）个随机整数，作为
字符串替换C语言数据结构(长度不定)
zhagoodwell查的博客
12-08 6895
字符串替换C语言数据结构(长度不定)尽管对程序的输入钻牛角尖 相信这个程序死不了^!^.
编程判断一个实数(任何位数)是否为0.5的整数倍
zhagoodwell查的博客
02-13 6054
如果用double 则 位数大于12后就不准确了  因此用 字符串比较合适  代码简单 不多说: # include int gainchar(char *a,int max);//输入数字 保存在a里 并返回 小数点的位置 如果没有小数点 返回0 # define N 101 int main(){ char B[N]; int A,C; do{ C=-1; A=gainc
哈夫曼编码
zhagoodwell查的博客
12-07 5019
不多说上代码： # include # include # include # define N 601  //如果想录入x个字节那么就把N的数值改成x+1  x>3 # define M 13          //哈夫曼树编码的长度 typedef struct ptree              //定义二叉树结点类型 { struct ptree *lchild;
八进制转十六进制
zhagoodwell查的博客
04-16 3675
点击打开题目链接 PID=1342八进制转十六进制Time Limit: 2000 MSMemory Limit: 65536 KBTotal Submissions: 395Accepted: 135DescriptionRTInput第一行为一个整数T，表示数据的组数一下T行 每行一个八进制数字串sOutput对于每组数据输出对应的十六进制字串Sample Input4777233233333...
相似基因序列
zhagoodwell查的博客
12-13 3269
众所周知，人类基因可以看作一个碱基对序列，它包含了4种核苷酸，简记为A,C,G,T。让我们观察这样一段基因序列 “ACCAGGTT”，这段序列共由8个核苷酸构成，其中第1位和第4位是碱基“A”，第2位和第3位是碱基“C”，第5位和第6位是碱基“G”，第7位和第8位是碱基“T”。Tom构造了这样一个0,1矩阵： 1, 0, 0, 1, 0, 0, 0, 0 0, 1, 1, 0, 0,
Python 数据归类
最新发布
09-08
3. 使用列表或集合：可以使用列表或集合来存储不同类别的数据。可以遍历数据并根据某些条件将数据添加到相应的类别中。 4. 使用机器学习算法：如果数据较大或者复杂，可以考虑使用机器学习算法对数据进行分类。可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值