并查集(二)

最新推荐文章于 2024-10-15 19:28:18 发布
最新推荐文章于 2024-10-15 19:28:18 发布
阅读量586 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56086076/article/details/130805464
版权

文章目录

前言

通过并查集(一)，相信读者已经对并查集有了很深刻的理解。下面，本篇文章会通过几道LeetCode上面的题目，带领大家巩固并查集的相关知识点。

一、多余的边

1.1 题目链接

点击跳转到题目位置

一模一样的题目，尝试将它通过吧

1.2 题目描述

树可以看成是一个连通且 无环 的 无向 图。

给定往一棵 n 个节点 (节点值 1～n) 的树中添加一条边后的图。添加的边的两个顶点包含在 1 到 n 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 n 的二维数组 edges ，edges[i] = [ai, bi] 表示图中在 ai 和 bi 之间存在一条边。

请找出一条可以删去的边，删除后可使得剩余部分是一个有着 n 个节点的树。如果有多个答案，则返回数组 edges 中最后出现的边。

1.3 题目代码

class Solution {
    int Find(vector<int>& pre, int index){
        while(pre[index] != index){
            index = pre[index];
        }
        return index;
    }

   void Join(vector<int>& pre, int index1, int index2){
        index1 = Find(pre, index1);
        index2 = Find(pre, index2);
        if(index1 != index2){
            pre[index1] = index2;
        }
    }

public:
    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
        int n = edges.size();
        vector<int> pre(1010);
        for(int i = 1; i <= n; ++i){
            pre[i] = i;
        }

        for(int i = 0; i < edges.size(); ++i){
            int x = edges[i][0];
            int y = edges[i][1];
            if(Find(pre, x) != Find(pre, y)){
                Join(pre, x, y);
            }
            else{
                return {x, y};
            }
        }
    return {};
    }
};

1.4 解题思路

(1) 遍历边，使用并查集将边连接的两个点加入到同一个集合中。如果在加入之前，这两个点已经在这个集合中，说明产生了环，只需要返回这两个点即可。(题目已经保证了，只需要删除一条冗余边就能满足了。

二、可能的二分法

2.1 题目链接

点击跳转到题目位置

2.2 题目描述

给定一组 n 人（编号为 1, 2, …, n）， 我们想把每个人分进任意大小的两组。每个人都可能不喜欢其他人，那么他们不应该属于同一组。

给定整数 n 和数组 dislikes ，其中 dislikes[i] = [ai, bi] ，表示不允许将编号为 ai 和 bi的人归入同一组。当可以用这种方法将所有人分进两组时，返回 true；否则返回 false。

2.3 题目代码

class Solution {
    int Find(vector<int>&pre , int index){
        while(pre[index] != index){
            index = pre[index];
        }
    return index;
    }

    void Union(vector<int>& pre, int index1, int index2){
        index1 = Find(pre, index1);
        index2 = Find(pre, index2);
        if(index1 != index2){
            pre[index1] = index2;
        }
    }

public:
    bool possibleBipartition(int n, vector<vector<int>>& dislikes) {
        int state[n+5][n+5];
        vector<int> pre(n+5);
        memset(state, 0, sizeof(state));
        for(int i = 1; i <= n; ++i){
            pre[i] = i;
        }

        for(int i = 0; i < dislikes.size(); ++i){
            int x = dislikes[i][0];
            int y = dislikes[i][1];
            state[x][y] = 1;
            state[y][x] = 1;
        }

        for(int i = 1; i <= n; ++i){
            int flag = 0;
            int t = -1;
            for(int j = 1; j <= n; ++j){
                if(state[i][j] == 1){
                    if(flag == 0){
                        t = j;
                        flag = 1;
                    }
                    else{
                        if(Find(pre, t) != Find(pre, j)){
                            Union(pre, t, j);
                        }
                    }
                }
            }
        }
        
        for(int i = 0; i < dislikes.size(); ++i){
            if(Find(pre, dislikes[i][0]) == Find(pre ,dislikes[i][1])){
                return false;
            }
        }
    
    return true;
    }
};

2.4 解题思路

(1) 用邻接矩阵的方式来存储不喜欢的状态。

(2) 因为分成两组，所以每个人不喜欢的人都应该放在与这个人不同的另一个组，所以使用并查集来进行并操作。

(3) 最后遍历最初的不喜欢人的数组，如果不喜欢的两个人通过并查集在一个分组了就返回false，否则返回true。

三、连通网络的操作次数

3.1 题目链接

点击跳转到题目位置

3.2 题目描述

用以太网线缆将 n 台计算机连接成一个网络，计算机的编号从 0 到 n-1。线缆用 connections 表示，其中 connections[i] = [a, b] 连接了计算机 a 和 b。

网络中的任何一台计算机都可以通过网络直接或者间接访问同一个网络中其他任意一台计算机。

给你这个计算机网络的初始布线 connections，你可以拔开任意两台直连计算机之间的线缆，并用它连接一对未直连的计算机。请你计算并返回使所有计算机都连通所需的最少操作次数。如果不可能，则返回 -1 。

3.3 题目代码

class Solution {
    int Find(vector<int>& pre, int index){
        while(pre[index] != index){
            index = pre[index];
        }
    return index;
    }

    void Union(vector<int>&pre, int index1, int index2){
        index1 = Find(pre, index1);
        index2 = Find(pre, index2);
        if(index1 != index2){
            pre[index1] = index2;
        }
    }

public:
    int makeConnected(int n, vector<vector<int>>& connections) {
        vector<int> pre(n);
        if(connections.size() < n - 1){
            return -1;
        }
        for(int i = 0; i < n; ++i){
            pre[i] = i;
        }
        for(int i = 0; i < connections.size(); ++i){
            int x = connections[i][0];
            int y = connections[i][1];
            if(Find(pre, x) != Find(pre, y)){
                Union(pre, x, y);
            }
        }
        int hash[n+5];
        memset(hash, 0, sizeof(hash));
        for(int i = 0; i < n; ++i){
            int num = Find(pre, i);
            hash[num] = 1;
        }
        int cnt = 0;
        for(int i = 0; i < n; ++i){
            if(hash[i] == 1){
                ++cnt;
            }
        }
    return cnt-1;
    }
};

3.4 解题思路

(1) 如果总的连接的线的根数，连n - 1都没有，那么一定不能将n台电脑连接起来。

(2) 使用并查集，将所有已经相连的电脑放置在同一个集合中。

(3) 记录集合的个数，最终最少操作次数等于集合数 减去 1。

四、等式方程的可满足性

4.1 题目链接

点击跳转到题目位置

4.2 题目描述

给定一个由表示变量之间关系的字符串方程组成的数组，每个字符串方程 equations[i] 的长度为 4，并采用两种不同的形式之一：“a==b” 或 “a!=b”。在这里，a 和 b 是小写字母（不一定不同），表示单字母变量名。

只有当可以将整数分配给变量名，以便满足所有给定的方程时才返回 true，否则返回 false。

4.3 题目代码

class Solution {
    int Find(vector<int>& pre, int index){
        while(pre[index] != index){
            index = pre[index];
        }
    return index;
    }

    void Union(vector<int>& pre, int index1, int index2){
        index1 = Find(pre, index1);
        index2 = Find(pre, index2);
        if(index1 != index2){
            pre[index1] = index2;
        }
    }

public:
    bool equationsPossible(vector<string>& equations) {
        vector<int> pre(26);
        for(int i = 0; i < 26; ++i){
            pre[i] = i;
        }
        for(int i = 0; i < equations.size(); ++i){
            int x = equations[i][0] - 'a';
            int y = equations[i][3] - 'a';
            char z = equations[i][1];
            if(z == '='){
                if(Find(pre, x) != Find(pre, y)){
                    Union(pre, x, y);
                }
            }
        }
        for(int i = 0; i < equations.size(); ++i){
            int x = equations[i][0] - 'a';
            int y = equations[i][3] - 'a';
            char z = equations[i][1];
            if(z == '!'){
                if(Find(pre, x) == Find(pre, y)){
                    return false;
                }
            }
        }
    return true;
    }
};

4.4 解题思路

(1) 利用并查集，将相等的元素放在一个集合当中。

(2) 然后再次遍历，如果两个元素不相等却在一个集合当中那么就判断为false。

(3) 如果没有判出false，就为true。

五、寻找图中是否存在路径

5.1 题目链接

点击跳转到题目位置

5.2 题目描述

有一个具有 n 个顶点的 双向 图，其中每个顶点标记从 0 到 n - 1（包含 0 和 n - 1）。图中的边用一个二维整数数组 edges 表示，其中 edges[i] = [ui, vi] 表示顶点 ui 和顶点 vi 之间的双向边。 每个顶点对由 最多一条 边连接，并且没有顶点存在与自身相连的边。

请你确定是否存在从顶点 source 开始，到顶点 destination 结束的 有效路径 。

给你数组 edges 和整数 n、source 和 destination，如果从 source 到 destination 存在 有效路径 ，则返回 true，否则返回 false 。

5.3 题目代码

class Solution {
    int Find(vector<int>& pre, int index){
        while(pre[index] != index){
            index = pre[index];
        }
    return index;
    }

    void Union(vector<int>& pre, int index1, int index2){
        index1 = Find(pre, index1);
        index2 = Find(pre, index2);
        if(index1 != index2){
            pre[index1] = index2;
        }
    }

public:
    bool equationsPossible(vector<string>& equations) {
        vector<int> pre(26);
        for(int i = 0; i < 26; ++i){
            pre[i] = i;
        }
        for(int i = 0; i < equations.size(); ++i){
            int x = equations[i][0] - 'a';
            int y = equations[i][3] - 'a';
            char z = equations[i][1];
            if(z == '='){
                if(Find(pre, x) != Find(pre, y)){
                    Union(pre, x, y);
                }
            }
        }
        for(int i = 0; i < equations.size(); ++i){
            int x = equations[i][0] - 'a';
            int y = equations[i][3] - 'a';
            char z = equations[i][1];
            if(z == '!'){
                if(Find(pre, x) == Find(pre, y)){
                    return false;
                }
            }
        }
    return true;
    }
};

5.4 解题思路

(1) 运用并查集，将相连的点并入一个集合当中。

(2) 通过并查集的查找，判断source和destination是否在同一个集合当中。

六、统计完全连通分量的数量

6.1 题目链接

点击跳转到题目位置

6.2 题目描述

给你一个整数 n 。现有一个包含 n 个顶点的 无向 图，顶点按从 0 到 n - 1 编号。给你一个二维整数数组 edges 其中 edges[i] = [ai, bi] 表示顶点 ai 和 bi 之间存在一条 无向 边。

返回图中 完全连通分量 的数量。

如果在子图中任意两个顶点之间都存在路径，并且子图中没有任何一个顶点与子图外部的顶点共享边，则称其为 连通分量 。

如果连通分量中每对节点之间都存在一条边，则称其为 完全连通分量 。

6.3 解题代码

class Solution {
    int Find(vector<int>& pre, int index){
        while(pre[index] != index){
            index = pre[index];
        }
        return index;
    }

   void Join(vector<int>& pre, int index1, int index2){
        index1 = Find(pre, index1);
        index2 = Find(pre, index2);
        if(index1 != index2){
            pre[index1] = index2;
        }
    }
    unordered_map<int, int> hash;
    unordered_map<int, int> point;
public:
    int countCompleteComponents(int n, vector<vector<int>>& edges) {
        int m = edges.size();
        vector<int> pre(100);
        for(int i = 0; i < n; ++i){
            pre[i] = i;
        }
        for(int i = 0; i < m; ++i){
            int x = edges[i][0];    
            int y = edges[i][1];
            Join(pre, x, y);
        }
    
        for(int i = 0; i < m; ++i){
            int x = edges[i][0];
            hash[Find(pre, x)]++;
        }
        for(int i = 0; i < n; ++i){
            point[Find(pre, i)]++;
        }
        int res = 0;
        for(int i = 0; i < n; ++i){
            if(i == pre[i]){
                if(hash[i] == (point[i] * (point[i] - 1)) / 2){
                    res++;
                }
            }
        }
    return res;
    }
};

6.4 解题思路

(1) 这道题目是问有多少个完全通量，那么我们首先要知道有多少个子图。那么我们可以用并查集来统计有多少个子图。

(2) 我们将并查集中统领子图中的所有节点的节点所连接的边和所拥有的点的数量统计出来。

(3) 遍历所有子图，已知点的数量n，已知边的数量m，如果m 等于(n * n-1) / 2，那么完全通量+1即可。

总结

本篇文章中的题目难度适中，建议读者按照需求将其完成。

HEU_firejef
关注
专栏目录
并查集是啥
Java和算法学习的博客
01-17 2832
文章目录一、啥是并查集1、解释2、有啥优势3、作用二、主要操作三、路径优化压缩四、核心方法1、查找节点所在集合的代表节点2、isSameSet(V a, V b)3、union(V a, V b)五、省份数量问题1、题目描述2、示例3、思路4、代码5、LeetCode测试 一、啥是并查集 1、解释 看下维基百科的解释 啥？在说啥，看不懂？那说人话吧 通俗的说，并查集是一种数据结构，指在一些有N个元素的集合应用问题中，通常在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并
Java实现并查集
08-18
二、Java实现并查集的接口 Java实现并查集的接口主要定义了三个方法：size()、isConnected()和unionElements()。其中，size()方法返回并查集中的元素个数；isConnected()方法判断两个元素是否相连；unionElements()...
【算法题解】54. 树的冗余连接
i余数的博客
08-19 373
给定往一棵 $n$ 个节点 (节点值 $1～n$) 的树中添加一条边后的图。添加的边的两个顶点包含在 $1$ 到 $n$ 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 $n$ 的二维数组 $edges$ ，$edges[i] = [ai, bi]$ 表示图中在 $ai$ 和 $bi$ 之间存在一条边。 请找出一条可以删去的边，删除后可使得剩余部分是一个有着 $n$ 个节点的树。如果有多个答案，则返回数组 $edges$ 中最后出现的那个。
【算法与数据结构】—— 并查集
热门推荐
酱懵静的博客
03-26 16万+
并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题（即所谓的并、查）。比如说，我们可以用并查集来判断一个森林中有几棵树、某个节点是否属于某棵树等。并查集主要由一个整型数组pre[ ]和两个函数find( )、join( )构成。 数组 pre[ ] 记录了每个点的前驱节点是谁，函数 find(x) 用于查找指定节点 x 属于哪个集合，函数 join(x,y) 用于合并两个节点 x 和 y 。
并查集Python版
小小博客
10-12 2039
整理之前python版的并查集资料
并查集
谦小白
01-13 5万+
文章目录一、并查集定义二、并查集思想三、并查集代码：(1)初始化(2)查找(3)合并四、路径压缩 一、并查集定义 1. 并查集是一种树型的数据结构，用于处理一些不相交集合（disjoint sets）的合并及查询问题。 2. 并查集通常包含两种操作 查找(Find)：查询两个元素是否在同一个集合中 合并(Union)：把两个不相交的集合合并为一个集合 注意：双亲结点就是父结点 二、并查集思想 如图现在大陆上有下面六位鼎鼎大名的忍者，且各自为王！     &
可持久化并查集
qq_45832461的博客
10-01 2222
可持久化并查集 题目描述 洛谷P3402 可持久化并查集 核心思路 可持久化并查集是建立在可持久化数组上的，在学习可持久化并查集之前，需要先学习主席树(可持久化权值线段树)，权值线段树，可持久化线段树，移步可持久化线段树1和可持久化线段树2 可持久化并查集=可持久化+并查集=可持久化数组+并查集=主席树+并查集 并查集有两种优化方式： 路径压缩 按秩合并 由于需要我们支持的只有集合的合并、查询操作，当我们需要将两个集合合二为一时，无论将哪一个集合连接到另一个集合的下面，都能得到正确的结果。但不同的连
并查集及其应用
gw_9527的博客
06-08 2555
并查集介绍 并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题。 并查集的初始化方法为先让所有的结点自成一个独立的集合,自己作为自己的簇头（是用簇头来标识集合的）；若已知两个元素属于同一集合，则将这两个元素所在的集合合并。 并操作：将两个元素所在的集合合并 查操作：找到给定元素的簇头 如下图所示就是unio（a , b）的过程， 此外在为了提高并查集的查询效率，一种很容易想到的做法为让并查集尽可能的矮，因此在查询的过程中，将查到的中间结点的都连到其簇头下面。 案例一：等式.
图-并查集
一个无聊的程序猿
01-25 1704
并查集 文章目录并查集1.定义2.意义3.root函数4.merge函数（union） 1.定义 什么是并查集？ 集：集合。 并：合并的意思，把集合合并在一起。 查：查询，查询某个集合。 并查集是一种树型的数据结构，判断一个森林中有几颗树，一个节点是否属于某棵树等。 森林？树？它们是什么。 试想一下，有nnn个图，它们彼此没有任何关系。每一个图就是一个单独的树，这nnn个树组成了一片树林。 2.意义 某天，AAA和BBB遇到了一起，他们同姓，于是他们猜想他们是否是亲戚？ 如果要验证他们的猜想，那就要去翻
并查集模板
panfengblog
11-03 3663
查并集模板 一拖再拖，总结一下吧 : ) 查并集常常用于处理一些合并和查询的问题，其中合并（union）和查询（find）是其最基本的两种操作，查并集算法主要有两种，一种是quick find，另一种quick union，顾名思义，就是分别跟倾向于其中一种操作。从一个题目入手，简要说明一下这个算法，并且给出解题的通用模板！ 1. 解题模板 1.1 例题 题目链接：洛谷 P1551 亲戚 题目背景 若某个家族人员过于庞大，要判断两个是否是亲戚，确实还很不容易，现在给出某个亲戚关系图，求任意给出的两个人是
【高阶数据结构(一)】并查集详解
杭电码农-NEO的博客
05-06 1489
本篇文章讲解了并查集的原理,并查集的模拟实现,并查集的应用.
C++并查集亲戚(Relations)算法实例
09-03
并查集（Disjoint Set）是一种数据结构，用于处理一些不相交集合的合并与查询问题。在C++中，实现并查集可以高效地解决亲戚关系查询的问题，特别是当关系网络庞大时。本实例主要关注如何使用并查集算法处理亲戚关系...
并查集（Union-Find）介绍.zip
04-12
并查集（Union-Find）是一种用于处理连接关系的数据结构，它在计算机科学中有着广泛的应用，尤其是在图论、算法设计以及数据结构的学习中。这个数据结构的主要目标是高效地解决“查找”和“合并”两个操作，常用于...
二叉树系列 10/11
2301_78191305的博客
10-11 422
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 239
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 189
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 377
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
c语言练习题2(字符串和函数的使用)
m0_74859128的博客
10-10 367
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
csdn_aspnet的专栏
10-14 1158
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
并查集解决二进制方程问题
并查集，又称为离散集合，是一种数据结构，主要用于处理不相交集合的合并问题。它在解决最小生成树问题，如Kruskal算法中发挥着关键作用。" 在二进制方程问题中，我们被赋予了一组变量，每个变量都有特定的长度，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值