并查集的几道题目

最新推荐文章于 2023-06-13 23:15:05 发布
最新推荐文章于 2023-06-13 23:15:05 发布
阅读量2.7k 收藏 3
点赞数
分类专栏： 解题报告
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Triose/article/details/47421333
版权

先从最简单的开始：

题意： 一共n个强盗，m条线索，输出有多少个独立团伙（同伙的同伙是同伙，老鼠的儿子会打洞）

样例输入：

10 9

1 2

3 4

5 2

4 6

2 6

8 7

9 7

1 6

2 4

样例输出：

3

代码：

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<map>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff                                            //INT_MAX
#define inf 0x3f3f3f3f                                            //int??????????????????
#define FOR(i,a) for((i)=0;i<(a);(i)++)                            //[i,a);
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define LL __int64
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) {return b ? gcd(b, a % b) : a;}
template<class T> T lcm(T a, T b) {return a / gcd(a, b) * b;}
template<class T> inline T Min(T a, T b) {return a < b ? a : b;}
template<class T> inline T Max(T a, T b) {return a > b ? a : b;}
using namespace std;
int n,m;
#define N 1010
int robber[N];
void Init(){<span style="white-space:pre">						</span>//初始化函数
	for(int i = 1; i <= n; i++){
		robber[i] = i;
	}
}
int getheader(int u){<span style="white-space:pre">					</span>//找爹函数
	if(robber[u] == u){
		return u;
	}
	else{
		return robber[u] = getheader(robber[u]);
	}
}
void merge(int u,int v){<span style="white-space:pre">				</span>//合并u，v强盗团伙的函数
	int t1,t2;
	t1 = getheader(u);
	t2 = getheader(v);
	if(t1 > t2){<span style="white-space:pre">					</span>//让标号比较大的强盗都归顺编号比较小的强盗
		t1 ^= t2;
		t2 ^= t1;
		t1 ^= t2;
	}
	if(t1 != t2){
		robber	[t2] = t1;
	}
}
int main(){
#ifndef ONLINE_JUDGE
//    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
#endif
	while(sfd(n,m) != EOF){
		Init();
		int r1,r2;
		for(int i = 0; i < m;i++){
			sfd(r1,r2);
			merge(r1,r2);
		}
		int num = 0;
		for(int i = 1; i <= n; i++){
			if(robber[i] == i)
				num++;
		}
		pf(num);
	}
    return 0;
}

没啥好总结的。。。

然后有变形。。。又是王教授出的。。

找朋友

时间限制(C/C++):1000MS/3000MS          运行内存限制:65536KByte
总提交:422            测试通过:138

描述

假设朋友关系是可以传递的，也就是说，如果A和B是朋友，B和C是朋友，那么A和C也是朋友。给出一个人员集合及其朋友关系，则这个集合可以分割成为不相交的子集合。给出一个人员的集合，以及他们之间部分的关系（哪两个人是朋友），让你求出分割出的子集合中最大的那个有多少人。

输入

第一行是一个整数，在[2,50]之间，表示要输入的案例的数量。对每个案例，第一行是2个整数，用空格隔开。第一个整数m表示集合的规模，第二个整数给出的关系数量n。后面紧跟n行，每一行都是两个整数x和y，满足0 <= x, y < n。0<n,m<100.

输出

对每一个案例，输出该集合分割后最大的那个子集合中的人数。

样例输入

2
4 4
0 3
2 1
3 1
0 2
5 5
0 1
1 2
0 2
3 4
4 3

样例输出

4
3
这下好，还要统计人数。。用个结构体就ok

代码：

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<map>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff                                            //INT_MAX
#define inf 0x3f3f3f3f                                            //int??????????????????
#define FOR(i,a) for((i)=0;i<(a);(i)++)                            //[i,a);
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define LL __int64
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) {return b ? gcd(b, a % b) : a;}
template<class T> T lcm(T a, T b) {return a / gcd(a, b) * b;}
template<class T> inline T Min(T a, T b) {return a < b ? a : b;}
template<class T> inline T Max(T a, T b) {return a > b ? a : b;}
using namespace std;
int n,m;
#define N 105
struct People{
    int header;
    int num;
};
People a[N];
void My_swap(int & a,int & b){
    a ^= b;     b ^= a;     a ^= b;
}
void Init(){
    for(int i = 0; i < n;i++){
        a[i].header = i;
        a[i].num = 1;
    }
}
int getheader(int t){
    if(a[t].header == t){
        return t;
    }
    else{
        return a[t].header = getheader(a[t].header);
    }
}
void merge(int u,int v){
    int t1,t2;
    t1 = getheader(u);
    t2 = getheader(v);
    if(t1 > t2){
        My_swap(t1,t2);<span style="white-space:pre">				</span>//其实这步并没有什么必要，好理解一点点
    }
    if(t1 != t2){
        a[t2].header = t1;
        a[t1].num += a[t2].num;
    }
}
int main(){
#ifndef ONLINE_JUDGE
//    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
#endif
    int t,x,y;
    sf(t);
    while(t--){
        sfd(n,m);
        Init();
        for(int i = 0; i < m; i++){
            sfd(x,y);
            merge(x,y);
        }
        int max_sum = 0;
        for(int i = 0; i < n; i++){
            max_sum = max_sum > a[i].num ? max_sum : a[i].num;
        }
        pf(max_sum);
    }
    return 0;
}
只是跑得慢了点。。。

还有一道变了变样子的题：

AQ and his xiaoqiang

时间限制(C/C++):1000MS/3000MS          运行内存限制:65536KByte
总提交:45            测试通过:8

描述

In AQ's dormitory,there are n xiaoqiang.They are so smart that they have their ways to know others as friends or enemies,
any two of them are friends or enemies if they know each other.And the relationship among them described as follows:
(we assume 3 xiaoqiang named A,B,C)
1.if A's friend is B,B's friend is C,so C is also a friend of A.
2.if A's enemy is B,B's enemy is C,so C is a friend of A.
We know a family consist of the xiaoqiang who are all friends between any two of them.So if I tell you 
m relationships among n xiaoqiang,can you tell me what is the maximum number of families in AQ's dormitory?

输入

There are multiple cases.In the first line,there is n and m,represents the number of xiaoqiang and the relationships.(n<1000, m<5000)
among them.In the following m rows,there are three numbers:p x y.
1.p=1,x and y are friends.
2.p=0,x and y are enemies.



输出

Please output the maximum number of families in one line.

样例输入

6 4
0 1 4
1 3 5
1 4 6
0 1 2

样例输出

3

居然是小强我也是醉了，还有敌人啊朋友我也是醉了

代码：

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<map>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff                                            //INT_MAX
#define inf 0x3f3f3f3f                                            //int??????????????????
#define FOR(i,a) for((i)=0;i<(a);(i)++)                            //[i,a);
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define LL __int64
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) {return b ? gcd(b, a % b) : a;}
template<class T> T lcm(T a, T b) {return a / gcd(a, b) * b;}
template<class T> inline T Min(T a, T b) {return a < b ? a : b;}
template<class T> inline T Max(T a, T b) {return a > b ? a : b;}
using namespace std;
int n,m;
#define N 1010
int a[N];
bool enem[N][N];
void Init(){
    memset(enem,false,sizeof(enem));
    for(int i = 0; i < N; i++)
        a[i] = i;
}
int geth(int t){
    if(a[t] == t){
        return t;
    }
    else{
        return a[t] = geth(a[t]);
    }
}
 
void merge(int u,int v){
    int t1 ,t2;
    t1 = geth(u);
    t2 = geth(v);
    if(t1 > t2){
        t1 ^= t2;
        t2 ^= t1;
        t1 ^= t2;
    }
    if(t1 != t2){
        a[t2] = t1;
    }
}
int main(){
    int p,x,y;
    while(sfd(n,m) != EOF){
        Init();
        for(int i = 0; i < m; i++){
            sft(p,x,y);
            if(p)
                merge(x,y);
            if(!p){
                enem[x][y] = true;            <span style="white-space:pre">	</span>//标记敌人
                enem[y][x] = true;<span style="white-space:pre">		</span>//一开始错就错在没加这句，既然是互为敌人那么两个都要标记！
            }
        }
        int temp = 0;
        for(int i = 1; i <= n; i++){
            for(int j = 1 ,indx = 0; j <= n; j++){
                if(enem[i][j] && indx == 0){
                    temp = j;<span style="white-space:pre">			</span>//第一个敌人和所有敌人都合并
                    indx++;
                }
                else if(enem[i][j]){
                    merge(temp,j);
                }
            }
        }
        int num = 0;
        for(int i = 1; i <= n; i++){
            if(a[i] == i)
                num++;
        }
        pf(num);
    }
    return 0;
}

这个算法还算比较简单。。



不过  简单是简单  当然有值得注意的地方

比如图中判断是否直接或者间接连接的问题时，例如CF的这道题

B. Mr. Kitayuta's Colorful Graph
time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output

Mr. Kitayuta has just bought an undirected graph consisting of n vertices and m edges. The vertices of the graph are numbered from 1 ton. Each edge, namely edge i, has a color ci, connecting vertex ai and bi.

Mr. Kitayuta wants you to process the following q queries.

In the i-th query, he gives you two integers — ui and vi.

Find the number of the colors that satisfy the following condition: the edges of that color connect vertex ui and vertex vi directly or indirectly.

Input

The first line of the input contains space-separated two integers — n and m (2 ≤ n ≤ 100, 1 ≤ m ≤ 100), denoting the number of the vertices and the number of the edges, respectively.

The next m lines contain space-separated three integers — ai, bi (1 ≤ ai < bi ≤ n) and ci (1 ≤ ci ≤ m). Note that there can be multiple edges between two vertices. However, there are no multiple edges of the same color between two vertices, that is, if i ≠ j,(ai, bi, ci) ≠ (aj, bj, cj).

The next line contains a integer — q (1 ≤ q ≤ 100), denoting the number of the queries.

Then follows q lines, containing space-separated two integers — ui and vi (1 ≤ ui, vi ≤ n). It is guaranteed that ui ≠ vi.

Output

For each query, print the answer in a separate line.

Sample test(s)
input 
4 5
1 2 1
1 2 2
2 3 1
2 3 3
2 4 3
3
1 2
3 4
1 4
output 
2
1
0
input 
5 7
1 5 1
2 5 1
3 5 1
4 5 1
1 2 2
2 3 2
3 4 2
5
1 5
5 1
2 5
1 5
1 4
output 
1
1
1
1
2
Note

Let's consider the first sample.

The figure above shows the first sample.
  • Vertex 1 and vertex 2 are connected by color 1 and 2.
  • Vertex 3 and vertex 4 are connected by color 3.
  • Vertex 1 and vertex 4 are not connected by any single color.


再例如这组数据：

5 4
2 3 1
2 5 1
2 4 1
2 1 1
4
1 2
1 3
1 4
1 5

通过合并先后把 (2,3) (2,5) (2,4) (2,1)  终点都是1这个点（通过颜色1连接）但是   3,4,5这三个点的终点并不是1，而是2，这就是这道题一直错的原因

说多了都是泪  贴代码！

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<memory.h>
#include<map>
#include<set>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff											//INT_MAX
#define inf 0x3f3f3f3f    										//int范围内可靠的无穷大
#define FOR(i,a) for((i)=0;i<(a);(i)++)							//
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define LL __int64
const double PI=acos(-1.0);
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
using namespace std;
int n,m,q;
#define N 110
int pic[N][N];
int num = 0;
int get_head(int p,int c){
	return pic[p][c] == p ? p : pic[p][c] = get_head(pic[p][c],c);
}
void merge(int p1,int p2,int c){
	int h1 = get_head(p1,c);
	int h2 = get_head(p2,c);
	if(h1 != h2){
		pic[h1 < h2 ? pic[p2][c] : pic[p1][c]][c] = h1 < h2 ? h1 : h2;
	}
}
void Init(){
	int point_1,point_2,color;
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){
			pic[i][j] = i;
		}
	}
	for(int i = 0; i < m; i++){
		sft(point_1,point_2,color);
		merge(point_1,point_2,color);
	}
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){
			pic[i][j] = get_head(pic[i][j],j);
		}
	}
}
void slove(){
	sf(q);
	int x,y;
	while(q--){
		num = 0;
		sfd(x,y);
		for(int i = 1; i <= m; i++){
			if(pic[x][i] == pic[y][i])
				num++;
		}
		pf(num);
	}
}
int main(){
#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);
//	freopen("Out.txt","w",stdout);
#endif
	while(~sfd(n,m)){
		Init();
		slove();
	}
	return 0;
}

Triose
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Union-Find算法详解
流楚丶格念的博客
06-01 3252
原文地址：https://www.jianshu.com/p/5f0db63ba54b今天讲讲 Union-Find 算法，也就是常说的并查集算法，主要是解决图论中「动态连通性」问题的。名词很高端，其实特别好理解，等会解释，另外这个算法的应用都非常有趣。说起这个 Union-Find，应该算是我的「启蒙算法」了，因为《算法4》的开头就介绍了这款算法，可是把我秀翻了，感觉好精妙啊！后来刷了 LeetCode，并查集相关的算法题目都非常有意思，而且《算法4》给的解法竟然还可以进一步优化，只要加一个微小的修改就可
并查集 检查网络
03-31
【问题描述】 ...若网络中任意两机器间都可以传输文件，则在一行中输出“The network is connected.”，否则输出“There are k components.”,其中k是网络中连通集的个数。两组测试数据之间请输出一空行分隔。
数学专题1
leohujx的博客
10-10 313
A:相当于已知 f[i] = 2*(f[i-1]+f[i-2])，然后求f(n),n大到2^60，所以我们无法用递推，此时我们就用矩阵快速幂。#include<stdio.h> #include<iostream> #include<string> #include<string.h> #include<algorithm> #include<iomanip> #include<vector> #i
算法提升：并查集的十个经典题目
阿呆的隐秘角落
10-30 3978
算法成神之路：并查集的十个经典题目
万字长文，并查集（Union Find）精讲及应用实例
白话机器学习
06-06 2328
并查集（Union Find）：一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。不交集指的是一系列没有重复元素的集合。合并（Union）：将两个集合合并成一个集合。查找（Find）：确定某个元素属于哪个集合。通常是返回集合内的一个「代表元素」。简单来说，并查集就是用来处理集合的合并和集合的查询。并查集中的「集」指的就是我们初中所学的集合概念，在这里指的是不相交的集合，即一系列没有重复元素的集合。
union-find（并查集）算法
trina121的博客
01-07 2672
背景: union-find算法是用来解决动态连通性问题的。 动态连通性问题的数学表达: 问题的输入是一列整数对。一个整数对可以被理解成这个整数对的两个整数相连。 eg：我们输入整数对 p,q，那么"p和q是相连的"。 相连:我们假设相连是一种对等的关系，就意味着它有 自反性:p和p是相连的 对称性:如果p和q相连，那么q和p也是相连的 传递性:如果p和q是相连的，q和r是相连的，那么p和r而是相连的 问题:我们已知一些整数对(即所有点的相连关系)，那么如何得知某两个点是否相连? 现实中的例子: 大型网
【算法提高班】并查集
01-20
我这里总结了几道并查集的题目： 547.朋友圈 721. 账户合并 990. 等式方程的可满足性 并查集概述 并查集算法，主要是解决图论中「动态连通性」问题的 Union-Find 算法解决的是图的动态连通性问题，这个算法本身不难...
并查集复习及其重要例题.pptx
08-12
如果给出各个元素之间的联系，要求将这些元素分成几个集合，每个集合中的元素直接或间接有联系。在这类问题中主要涉及的是对集合的合并和查找，因此将这种集合称为并查集
C++并查集亲戚(Relations)算法实例
01-20
本文实例讲述了C++并查集亲戚(Relations)算法。分享给大家供大家参考。具体分析如下： 题目： 亲戚(Relations) 或许你并不知道，你的某个朋友是你的亲戚。他可能是你的曾祖父的外公的女婿的外甥的表姐的孙子。如果能...
并查集代码
12-12
关于并查集的几道经典题目，希望对大家有所帮助
并查集(Union-Find) (图文详解)
qq_57469718的博客
06-22 9595
并查集 数据结构 算法 Leetcode
并查集简介及典型例题
Fan
07-10 1607
文章目录1 并查集原理介绍2 典型例题 1 并查集原理介绍 网上有篇博文写的不错，为了方便直接摘抄记录下来。 参考链接：https://blog.csdn.net/qq_41593380/article/details/81146850 并查集听着比较高端，其实道理很简单。参考某高手的blog。通过读完这个故事，加上几个练习，你也能轻松了解这个名词，吹吹逼了，哈哈~ 故事如下： 江湖上散落着各式各样的大侠，有上千个之多。他们没有什么正当职业，整天背着剑在外面走来走去，碰到和自己不是一路人的，就免不了要打一架
数据结构| 并查集（附例题）
qq_43528044的博客
05-31 304
并查集 初步认识 顾名思义，并查集三个字拆开就是，“合并、查找、集合”。 实现形式，通过数据表示，其中数据的下标表示数据的值，数组的值表示指向的父亲节点。因此可得当father[i] = i的时候我们可以知道这表示的就是集合的根结点。 基本操作 初始化，每一个节点都作为一个独立的树 查找父节点，递归或者循环 终止条件father[i] = i 合并， 合并两个树需要找到父节点在进行合并 ...
并查集算法（union-find）
夜夜夜夜
04-27 819
就动态连通性这个场景而言，我们需要解决的问题可能是： 给出两个节点，判断它们是否连通，如果连通，不需要给出具体的路径 给出两个节点，判断它们是否连通，如果连通，需要给出具体的路径就上面两种问题而言，虽然只有是否能够给出具体路径的区别，但是这个区别导致了选择算法的不同，本文主要介绍的是第一种情况，即不需要给出具体路径的Union-Find算法，而第二种情况可以使用基于DFS的算法。 题目1：畅通
并查集+经典例题
qq_43721152的博客
01-31 2938
查并集原来以前看过，当时看的那篇文章编了一个江湖的关系，令我印象深刻，可惜我找不到了。 查并集相当于并集，把没有关系的集合分开 可以想象为朋友圈，我朋友的朋友，跟我是一个朋友圈的。 基础 模板题 #include<bits/stdc++.h> using namespace std; const int maxn=2e5+10; int n,m; int z,x,y; int f[ma...
union-find算法（并查集）
li1358159的博客
02-14 870
任何一种算法都是为解决某个问题而生的，union-find是用于解决动态连通性问题的一种算法。
并查集思想及例题
weixin_46438976的博客
02-20 674
并查集是一种非常精巧而实用的数据结构，它主要用于处理一些不相交集合的合并和查询问题。经典的应用有：判断连通性、最小生成树 Kruskal 算法、最近公共祖先（Least Common Ancestors, LCA）等。并查集在算法竞赛中也十分常见：一是简单且高效，二是应用很直观，三是容易和其他数据结构和算法结合。 例题： 剪邮票 - 蓝桥云课 (lanqiao.cn) ...
【并查集】经典例题（一）
最新发布
SY奇星的OI博客
06-13 179
战舰。
【数据结构和算法】并查集的基本概念和例题收集
weixin_51574797的博客
10-06 889
介绍了并查集的一些基础概念,初始化,路径压缩的find,,已经按照大小合并和按照秩合并,以及一些leetcode上面的一些例题
请出一道考察并查集的算法竞赛题目
04-21
现在需要你实现一个并查集，支持以下操作： 1. 合并两个点所在的集合，并将新集合中点权值大的点为代表点。 2. 查询某个点所在的集合的代表点。 3. 查询某个点所在集合的所有点的权值之和。 输入格式: 输入第一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值