【算法基础：数据结构】2.3 并查集

已于 2023-11-27 17:04:43 修改
阅读量824 收藏
点赞数
分类专栏： 算法 文章标签： 算法 数据结构 java 并查集 路径压缩
于 2023-07-19 17:41:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43406895/article/details/131746245
版权

文章目录

并查集

https://oi-wiki.org/ds/dsu/
在这里插入图片描述

操作：

  1. 将两个集合合并
  2. 询问两个元素是否在一个集合当中

（路径压缩优化之后）：近乎 O ( 1 ) O(1) O(1)

算法原理（重要！⭐）

在这里插入图片描述

将每个集合使用树的形式存储。

每个集合的编号 是 树根的编号。

每个节点存储 它的父节点是谁。 p[x] 表示 x 的父节点。

Q：如何判断树根？
A：p[x] == x

Q：如何求 x 的集合编号？
A：while (p[x] != x) x = p[x];
使用 路径压缩 的话就是 if (p[x] != x) p[x] = find(x);

Q：如何合并两个集合？
A：p[x] = y，即 把一棵树的根节点当成另一个树根节点的儿子。 （优化！：将这棵树中的所有节点都当成另一棵树根节点的子节点——优化之后几乎就是 O ( 1 ) O(1) O(1) 的了）（这个优化叫做 路径压缩）

时间和空间复杂度

经典例题

836. 合并集合（重要！模板！⭐）

https://www.acwing.com/activity/content/problem/content/885/
在这里插入图片描述

注意下面 find(x) 的写法。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static int[] p;
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(), m = scanner.nextInt();
        p = new int[n + 1];
        Arrays.setAll(p, e -> e);   // 初始化，各个节点的祖宗节点设置成自己
        while (m-- != 0) {
            char op = scanner.next().charAt(0);
            int a = scanner.nextInt(), b = scanner.nextInt();
            if (op == 'M') {
                p[find(a)] = find(b);
            } else {
                if (find(a) == find(b)) System.out.println("Yes");
                else System.out.println("No");
            }
        }
    }

    // 返回 x 的祖宗节点 + 路径压缩
    static int find(int x) {
        if (p[x] != x) p[x] = find(p[x]);	// 路径压缩
        return p[x];
    }
}

837. 连通块中点的数量（维护连通块大小的并查集）

https://www.acwing.com/activity/content/problem/content/886/

在这里插入图片描述

find(x) 方法没有变化。

在合并两个点时：
先检查两个点是否已经在同一个连通块里了，直接 continue；
否则，先将一个点的根节点维护的数量加到另一个点的根节点维护的数量，然后再合并这两个点。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static int[] p, size;       // p[i][0]是父节点  p[i][1]是该连通块中点的数量
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(), m = scanner.nextInt();
        p = new int[n + 1];
        size = new int[n + 1];
        Arrays.setAll(p, e ->e);   // 初始化，各个节点的祖宗节点设置成自己
        Arrays.fill(size, 1);   // 初始化每个连通块的大小是 1
        while (m-- != 0) {
            String op = scanner.next();
            int a = scanner.nextInt();
            if ("C".equals(op)) {
                int b = scanner.nextInt();
                if (find(a) == find(b)) continue;       // 已经在同一个连通块里了
                size[find(b)] += size[find(a)];
                p[find(a)] = find(b);
            } else if ("Q1".equals(op)) {
                int b = scanner.nextInt();
                if (find(a) == find(b)) System.out.println("Yes");
                else System.out.println("No");
            } else {
                System.out.println(size[find(a)]);
            }
        }
    }

    // 返回 x 的祖宗节点 + 路径压缩
    static int find(int x) {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }
}

240. 食物链（维护额外信息的并查集）🚹🚹🚹

https://www.acwing.com/activity/content/problem/content/887/
在这里插入图片描述

同一个集合表示：这一个集合内的所有动物之间的关系都可以确定。

对于每一句话中的 x 和 y，先检查它们是否在一个集合里，如果在同一个集合里，那么就可以判断这句话是否是假话。
如果是假话—— ++ans
如果是真话—— 将它们所在的两个集合合并。

如何确定同一个集合里各个动物之间的关系？
使用 d 数组维护各个节点到根节点之间的距离。（具体可以看下图：）

在这里插入图片描述
注意看代码中注释的解释。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static int[] p, d;
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(), k = scanner.nextInt(), ans = 0;
        // 一个集合里的所有动物之间的关系是可以推理出来的（这里同一个连通块并不表示它们是同一个种类，而是它们之间的关系可以确定）
        // 记录每个点和根节点的关系（用每个点和根节点之间的距离来表示它和根节点之间的距离）
        p = new int[n + 1];
        Arrays.setAll(p, e ->e);    // 初始化，各个节点的祖宗节点设置成自己
        d = new int[n + 1];         // d 维护的是各个节点到根节点的距离（距离表示它和根节点之间的关系）

        while (k-- != 0) {
            int op = scanner.nextInt(), x = scanner.nextInt(), y = scanner.nextInt();
            if (x > n || y > n) {               // x 或 y 比 n 大 —— 是假话
                ++ans;
                continue;
            }

            int px = find(x), py = find(y);     // 找到 x 和 y 的祖宗节点
            if (op == 1) {
                if (px == py && (d[x] - d[y]) % 3 != 0) ++ans;  // 已经在一个集合里了，判断是否合理
                else if (px != py) {            // 不在一个集合里，确定关系
                    p[px] = p[py];
                    d[px] = d[y] - d[x];        // 是为了令 d[px] + d[x] == d[y]
                }
            } else {
                if (px == py && (d[x] - d[y] - 1) % 3 != 0) ans++;  // 已经在一个集合里了，判断是否合理
                else if (px != py) {
                    p[px] = py;
                    d[px] = d[y] - d[x] + 1;    // x 吃 y，是为了令d[px] + d[x] = d[y] + 1。
                }
            }
        }
        System.out.println(ans);
    }

    static int find(int x) {
        if (p[x] != x) {
            int t = find(p[x]);     // t 是 x 的父节点的父节点
            d[x] += d[p[x]];        // 在路径压缩的过程中，子节点需要继承父节点到根节点的距离。（因为没压缩之前 d[x]是x到p[x]之间的距离）
            p[x] = t;
        }
        return p[x];
    }
}

关于 d[px] 的确定：
在这里插入图片描述

相关题目练习

684. 冗余连接（并查集寻找冗余的边）

https://leetcode.cn/problems/redundant-connection/
在这里插入图片描述

从前往后枚举每个边，将边的两个节点所在的集合合并，如果两个节点已经在同一个集合里了，说明这条边是多余的，那就保留这条边作为答案。

class Solution {
    public int[] findRedundantConnection(int[][] edges) {
        int n = edges.length;
        int[] p = new int[n + 1], ans = new int[]{-1, -1};
        Arrays.setAll(p, e -> e);
        for (int[] edge: edges) { 
            int x = edge[0], y = edge[1];
            if (find(x, p) == find(y, p)) ans = edge;   // 如果已经在一个集合了，说明这条边是多余的
            else p[find(x, p)] = find(y, p);            // 合并两个集合
        }
        return ans;
    }

    int find(int x, int[] p) {
        if (x != p[x]) p[x] = find(p[x], p);
        return p[x];
    }
}

685. 冗余连接 II⭐（分情况讨论）

https://leetcode.cn/problems/redundant-connection-ii/

在这里插入图片描述

需要选择一条边删除，删除之后使得有向图变成一个有根树。（有根树的定义见 题目）。

删除边之前，删除边的原因有三种：

  1. 有环
  2. 有冲突，两个节点指向了同一个节点
  3. 既有环又有冲突

解法参考：https://programmercarl.com/0685.%E5%86%97%E4%BD%99%E8%BF%9E%E6%8E%A5II.html#%E6%80%9D%E8%B7%AF

如果图中存在冲突，则一定需要删除冲突的两个边其中之一。
如果没有冲突，则一定存在环，使用并查集找到哪条边出现后图中出现了环。 

class Solution {
    int[] p = new int[1001];

    public int[] findRedundantDirectedConnection(int[][] edges) {
        int n = edges.length;
        Arrays.setAll(p, e -> e);
        int[] inDegree = new int[n + 1];
        for (int[] e: edges) inDegree[e[1]]++;
        List<Integer> ls = new ArrayList();       // 记录入度为2的节点所对应的边
        for (int i = 0; i < n; ++i) {
            if (inDegree[edges[i][1]] == 2) ls.add(i);
        }

        // 检查删除哪条造成入度=2的边可以让图变成有根树
        if (ls.size() > 0) {
            if (isTreeAfterRemoveEdge(edges, ls.get(1))) return edges[ls.get(1)];
            else return edges[ls.get(0)];
        }

        // 删除造成有向环的那个
        return getRemoveEdge(edges);
    }

    int find(int x) {
        if (x != p[x]) p[x] = find(p[x]);
        return p[x];
    }

    // 检查删除一条边之后是否是有根树
    boolean isTreeAfterRemoveEdge(int[][] edges, int k) {
        for (int i = 0; i < edges.length; ++i) {
            if (i == k) continue;
            int x = edges[i][0], y = edges[i][1];
            if (find(x) == find(y)) return false;
            p[find(x)] = find(y);
        }
        return true;
    }

    // 检查存在环的情况下应该删除哪条边
    int[] getRemoveEdge(int[][] edges) {
        for (int[] e: edges) {
            int x = e[0], y = e[1];
            if (find(x) == find(y)) return e;
            p[find(x)] = find(y);
        }
        return new int[]{-1, -1};
    }
}

734. 句子相似性（这题不需要使用并查集）

https://leetcode.cn/problems/sentence-similarity/
在这里插入图片描述
提示:

1 <= sentence1.length, sentence2.length <= 1000
1 <= sentence1[i].length, sentence2[i].length <= 20
sentence1[i] 和 sentence2[i] 只包含大小写英文字母
0 <= similarPairs.length <= 2000
similarPairs[i].length == 2
1 <= xi.length, yi.length <= 20
所有对 (xi, yi) 都是 不同 的

class Solution {
    public boolean areSentencesSimilar(String[] sentence1, String[] sentence2, List<List<String>> similarPairs) {
        int n = sentence1.length;
        if (n != sentence2.length) return false;
        // 构建相似映射
        Map<String, Set<String>> m = new HashMap<>();
        for (List<String> s: similarPairs) {
            String a = s.get(0), b = s.get(1);
            m.computeIfAbsent(a, key -> new HashSet<>()).add(b);
            m.computeIfAbsent(b, key -> new HashSet<>()).add(a);
        }
        // 逐个检查
        for (int i = 0; i < n; ++i) {
            String s1 = sentence1[i], s2 = sentence2[i];
            if (!s1.equals(s2) && !m.getOrDefault(s1, new HashSet<>()).contains(s2)) return false;
        }
        return true;
    }
}

737. 句子相似性 II

https://leetcode.cn/problems/sentence-similarity-ii/

在这里插入图片描述

这一题的相似关系是可传递的，所以可以使用并查集。
由于是字符串之间的关系，使用哈希表来代替数据存储并查集结构。

class Solution {
    // 使用哈希表记录每个节点的父节点
    Map<String, String> p = new HashMap<>();

    public boolean areSentencesSimilarTwo(String[] sentence1, String[] sentence2, List<List<String>> similarPairs) {
        int n = sentence1.length;
        if (n != sentence2.length) return false;
        // 构建并查集
        for (List<String> s: similarPairs) {
            String a = s.get(0), b = s.get(1);
            p.put(find(a), find(b));
        }
        // 逐个检查
        for (int i = 0; i < n; ++i) {
            String a = sentence1[i], b = sentence2[i];
            if (!find(a).equals(find(b))) return false;
        }
        return true;
    }

    public String find(String x) {
        if (!p.containsKey(x)) p.put(x, x);
        if (!x.equals(p.get(x))) p.put(x, find(p.get(x)));
        return p.get(x);
    }
}

721. 账户合并

https://leetcode.cn/problems/accounts-merge/description/

在这里插入图片描述
提示：

1 <= accounts.length <= 1000
2 <= accounts[i].length <= 10
1 <= accounts[i][j].length <= 30
accounts[i][0] 由英文字母组成
accounts[i][j] (for j > 0) 是有效的邮箱地址

使用并查集维护各个邮件之间的关系。
使用哈希表记录每个集合代表邮件与账户名之间的关系。

class Solution {
    Map<String, String> m = new HashMap<>();

    public List<List<String>> accountsMerge(List<List<String>> accounts) {
        for (List<String> acc: accounts) {
            for (int i = 1; i < acc.size() - 1; ++i) {
                m.put(find(acc.get(i)), find(acc.get(i + 1)));
            }
        }

        // 记录各个集合的邮件列表
        Map<String, Set<String>> m2 = new HashMap<>();
        // 记录各个集合代表邮件和姓名的映射
        Map<String, String> m3 = new HashMap<>();
        for (List<String> acc: accounts) {
            for (int i = 1; i < acc.size(); ++i) {
                String s = acc.get(i), k = find(s);
                if (!m2.containsKey(k)) {
                    m2.put(k, new HashSet<>());
                    m3.put(k, acc.get(0));
                }
                m2.get(k).add(s);
            }
        }

        // 得到答案
        List<List<String>> ans = new ArrayList<>();
        for (String k: m2.keySet()) {
            List<String> t = new ArrayList<>();
            Set<String> s = m2.get(k);
            for (String ss: s) t.add(ss);
            Collections.sort(t);
            t.add(0, m3.get(k));
            ans.add(t);
        }
        return ans;
    }

    public String find(String x) {
        if (!m.containsKey(x)) m.put(x, x);
        if (!x.equals(m.get(x))) m.put(x, find(m.get(x)));
        return m.get(x);
    }
}

相关链接

https://oi-wiki.org/ds/dsu/

其余相关题目

1851. 包含每个查询的最小区间

1851. 包含每个查询的最小区间
在这里插入图片描述
提示：
1 <= intervals.length <= 10^5
1 <= queries.length <= 10^5
intervals[i].length == 2
1 <= lefti <= righti <= 10^7
1 <= queries[j] <= 10^7

见：【LeetCode每日一题合集】2023.7.17-2023.7.23（⭐离线算法 & 环形子数组的最大和 & 接雨水）

Wei *
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
下班前几分钟，我彻底弄懂了并查集
⚡
01-27 4852
详解并查集概念及其应用
数据结构与算法
weixin_59327092的博客
01-10 2333
数据结构与算法
数据结构之并查集：按秩合并与路径压缩优化
Sakura_lht
11-15 2111
并查集 1.并查集描述 一些有NNN个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。 为了快速解决这些问题，便有了并查集的概念。 并查集维护了一个不相交的动态集的集合S1,S2,⋯ ,Sn{S_1,S_2,\cdots,S_n}S1​,S2​,⋯,Sn​，每个集合将有一个"首领"来标识该集...
c++并查集（详细总结）
YSJ367635984的博客
02-01 6123
老话重谈，先看定义 并查集是一种树型的数据结构，用于处理一些不相交集合（disjoint sets）的合并及查询问题。常常在使用中以森林来表示。 首先得明白一些概念： 什么是树，什么是森林（由树组成的叫森林hh），什么是集合 这些问题是其他范畴的知识，就不过多累赘了，不了解的同学建议提前了解先。 下面我们切入重点 1、并查集 首先，我个人认为并查集在逻辑上是一个森林，该森林内由一棵或多棵数组成，如下举个例子 这三棵树可以组成一个森林，而这个森林可以叫并查集，每棵树可以称为并查集分量，这是逻辑上的理解
《王道》数据结构笔记整理2022
热门推荐
池鱼
08-21 22万+
数据结构第一章绪论1.1数据结构的基本概念1.2数据结构的三要素1.3算法的基本概念1.4算法的时间复杂度1.5算法的空间复杂度 第一章绪论 1.1数据结构的基本概念 1.数据：数据是信息的载体，是描述客观事物属性的数、字符以及所有能输入到计算机中并被程序识别和处理的符号的集合。 2.数据元素：数据元素是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如，学生记录就是一个数据元素，它由学号、姓名、性别等数据项组成。 3.数据对象:数
数据结构(全)
s6664的博客
06-21 5万+
线性结构, 树形结构, 图结构, 排序, 查找, 数据结构, 算法
并查集(C++实现)
Brant_zero的博客
08-25 1551
通过贴近生活的举例带你理解数据结构中的并查集，并查集是一种非常实用的数据结构，可以解决很多不相交集合的合并及查询问题。主要的应用场景有：连通性问题、最小生成树……
【结构与算法】—— 数据结构代码总结 | 数据结构代码大全
看世界，也找自己
10-17 1万+
数据结构是计算机科学与技术专业、计算机信息管理与应用专业，电子商务等专业的基础课，是十分重要的核心课程。所有的计算机系统软件和应用软件都要用到各种类型的数据结构。
算法+数据结构 Python实现 + 图解
noobiee的博客
03-12 3257
排序算法 Sorting algorithms 插入排序 (Insertion sort) 第n个元素依次比较前n-1个已排序好的数组元素直到插入相应位置 平均时间复杂度：O(n²) 空间复杂度：O(1) def insertion_sort(seq): for j in range(1, len(seq)): key = seq[j] i = j - 1 while i >= 0 and seq[i] > key: seq[i + 1] = seq[i]
408数据结构学习强化——常见数据结构定义和算法总结
JiangNan_1002的博客
09-27 1万+
1.数组 2.链表 3.栈 4.队列 5.树 6.图 7.排序 8.查找
22：Spark2.3.x编程模型.zip
03-08
本章将深入探讨Spark的编程模型，包括RDD（弹性分布式数据集）、DataFrame和DataSet，以及它们在Spark SQL、Streaming和MLlib库中的应用。 1. **RDD（Resilient Distributed Datasets）** - **定义**：RDD是Spark...
最小生成树数据结构实验报告范本模板.docx
06-04
Kruskal算法通过并查集数据结构来判断新加入的边是否会形成环路。算法按边的权值从小到大处理，如果加入这条边不会导致环路，则将其加入到生成树中，直到所有节点都被包含。 通过本次实验，学生能够深入理解最小...
数据结构、算法与应用：C++语言描述（原书第2版）第二部分
12-06
6.5.4 并查集 第7章 数组和矩阵 7.1 数组 7.1.1 抽象数据类型 7.1.2 C++数组的索引 7.1.3 行主映射和列主映射 7.1.4 用数组的数组来描述 7.1.5 行主描述和列主描述 7.1.6 不规则二维数组 7.2 矩阵 7.2.1 定义和操作 ...
leetcode双人赛-algorithm:算法
06-30
leetcode双人赛 1 前言 ...并查集 2.5 图论 最短路 最小生成树 2.6 数论 辗转相除法 素数 快速幂 3 中级算法 3.1 二分搜索 最大化最小值 01分数规划 第k大值 最小化第k大值 其他二分搜索 3.2 常用技巧
PySpark大数据处理及机器学习Spark2.3视频课程
11-15
在Spark 2.3中，MLlib进一步提升了模型训练的效率，优化了梯度下降算法，并引入了更多先进的机器学习技术，如深度学习框架TensorFlow的集成，使得在大规模数据集上进行深度学习成为可能。 在大数据处理方面，...
【18】输出字符菱形
2301_78786609的博客
07-19 366
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
2024.7.19 刷题总结
最新发布
TheJustice_的博客
07-19 223
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
(算法)区间调度问题
2202_75519246的博客
07-17 238
此外,参与工作的时间段不能重复(即使是开始的瞬间和结束的瞬间的重叠也是不允许的). 你的目标是参与尽王多的工作,那么最多能参与多少项工作呢?有n项工作,每项工作分别在s时间开始,在t时间结束. 对于每项工作,你都可以选择参与与否,如果选择了参与,那么自始至终都必须全程参与.
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 173
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
数据库技术：数据结构与算法详解（2.1-2.3）
在三级数据库技术的第二章——数据结构与算法中，本章占据了总分的15%，内容涵盖了数据结构的基础理论和常见操作。首先，章节开始介绍了数据结构与算法的基本概念，包括数据的定义，它是计算机能够识别、存储和处理...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wei *

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值