55.【必备】并查集-上

于 2025-05-05 10:00:00 发布
阅读量1.8k 收藏 37
点赞数 27
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法 文章标签： 算法 java 数据结构 并查集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/XY_StarField/article/details/147251145

本文的网课内容学习自B站左程云老师的算法详解课程，旨在对其中的知识进行整理和分享~

网课链接：算法讲解056【必备】并查集-上_哔哩哔哩_bilibili

一.并查集模板（路径压缩＋小挂大）

题目：并查集的实现

算法原理

  • 并查集基础概念
    • 并查集主要用于处理不相交集合的合并与查询问题。
    • 在这个代码中，每个元素最初都属于自己单独的集合，然后通过合并操作将一些集合合并在一起，并且可以查询两个元素是否在同一个集合中。
  • 数据结构部分（build函数）
    • father数组
      • 用于存储每个元素的父节点，初始时每个元素的父节点是它自己，即father[i]=i。这表示每个元素都是一个单独集合的代表。
      • 随着合并操作的进行，father数组会不断更新，使得同一集合中的元素最终指向同一个代表元素。
    • size数组
      • 用于存储每个集合的大小。初始时每个集合只有一个元素，所以size[i]=1。
      • 在合并操作时，会根据集合大小来决定合并的方式，以保持树形结构相对平衡，提高后续查询操作的效率。
    • stack数组
      • 这是一个辅助数组，用于在查找操作（find函数）中的路径压缩过程。
  • 查找操作（find函数）
    • 目的是找到给定元素所在集合的代表元素。
    • 从给定元素i开始，沿着father指针不断向上查找，直到找到一个元素j使得father[j]=j，这个j就是i所在集合的代表元素。
    • 在向上查找过程中，将经过的元素存储到stack数组中，记录经过的元素个数size。
    • 找到代表元素后，再将stack数组中的元素的father指针直接指向代表元素，实现路径压缩。路径压缩可以减少后续查找操作的时间复杂度，使得查找操作接近常数时间。
  • 判断是否在同一集合（isSameSet函数）
    • 通过调用find函数分别找到元素x和y的代表元素。
    • 如果这两个代表元素相同，就说明x和y在同一个集合中，返回true（输出"Yes"）；否则，返回false（输出"No"）。
  • 合并操作（union函数）
    • 首先调用find函数找到元素x和y的代表元素fx和fy。
    • 如果fx和fy不相等，说明x和y不在同一个集合中，需要进行合并操作。
    • 比较fx和fy所代表集合的大小（通过size数组）。
    • 如果size[fx]>=size[fy]，则将fy所在集合合并到fx所在集合中，即将fy的父节点设为fx（father[fy]=fx），并且更新fx所在集合的大小（size[fx]+=size[fy]）；否则，将fx所在集合合并到fy所在集合中，相应地更新father和size数组。

代码实现

// 并查集模版(牛客)
// 路径压缩 + 小挂大
// 测试链接 : https://www.nowcoder.com/practice/e7ed657974934a30b2010046536a5372
// 请同学们务必参考如下代码中关于输入、输出的处理
// 这是输入输出处理效率很高的写法
// 提交以下的code，提交时请把类名改成"Main"，可以直接通过

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Code01_UnionFindNowCoder {

    public static int MAXN = 1000001;

    public static int[] father = new int[MAXN];

    public static int[] size = new int[MAXN];

    public static int[] stack = new int[MAXN];

    public static int n;

    public static void build() {
        for (int i = 0; i <= n; i++) {
            father[i] = i;
            size[i] = 1;
        }
    }

    // i号节点，往上一直找，找到代表节点返回！
    public static int find(int i) {
        // 沿途收集了几个点
        int size = 0;
        while (i != father[i]) {
            stack[size++] = i;
            i = father[i];
        }
        // 沿途节点收集好了，i已经跳到代表节点了
        while (size > 0) {
            father[stack[--size]] = i;
        }
        return i;
    }

    public static boolean isSameSet(int x, int y) {
        return find(x) == find(y);
    }

    public static void union(int x, int y) {
        int fx = find(x);
        int fy = find(y);
        if (fx != fy) {
            // fx是集合的代表：拿大小
            // fy是集合的代表：拿大小
            if (size[fx] >= size[fy]) {
                size[fx] += size[fy];
                father[fy] = fx;
            } else {
                size[fy] += size[fx];
                father[fx] = fy;
            }
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            n = (int) in.nval;
            build();
            in.nextToken();
            int m = (int) in.nval;
            for (int i = 0; i < m; i++) {
                in.nextToken();
                int op = (int) in.nval;
                in.nextToken();
                int x = (int) in.nval;
                in.nextToken();
                int y = (int) in.nval;
                if (op == 1) {
                    out.println(isSameSet(x, y) ? "Yes" : "No");
                } else {
                    union(x, y);
                }
            }
        }
        out.flush();
        out.close();
        br.close();
    }

}

二.并查集模板（只有路径压缩）

题目：【模板】并查集

算法原理

  • 基础概念与数据结构
    • 并查集用于处理不相交集合的合并与查询问题。
    • father数组
      • 这个数组用于存储每个元素的父节点。初始时，在build函数中，每个元素的父节点被设置为它自己，即father[i]=i，表示每个元素是一个单独集合的初始代表。
  • 查找操作（find函数）
    • 这个函数的目的是找到元素所在集合的代表元素。
    • 采用递归的方式实现路径压缩。当i!=father[i]时，先递归调用find函数找到father[i]的代表元素，然后将father[i]直接指向这个代表元素。这样做的好处是在后续查询中，可以减少查找的深度，提高查询效率。最后返回找到的代表元素father[i]。
  • 判断是否在同一集合（isSameSet函数）
    • 分别调用find函数找到元素x和y的代表元素。
    • 如果这两个代表元素相同，说明x和y在同一个集合中，返回true（输出"Y"）；否则，返回false（输出"N"）。
  • 合并操作（union函数）
    • 直接将x所在集合的代表元素（通过find(x)找到）的父节点设置为y所在集合的代表元素（通过find(y)找到）。这里没有像之前的代码那样进行小挂大的优化，在数据规模不是非常大或者对效率要求不是极高的情况下，这种简单的合并操作也是可行的。

代码实现

// 并查集模版(洛谷)
// 本实现用递归函数实现路径压缩，而且省掉了小挂大的优化，一般情况下可以省略
// 测试链接 : https://www.luogu.com.cn/problem/P3367
// 请同学们务必参考如下代码中关于输入、输出的处理
// 这是输入输出处理效率很高的写法
// 提交以下的code，提交时请把类名改成"Main"，可以直接通过

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Code02_UnionFindLuogu {

    public static int MAXN = 200001;

    public static int[] father = new int[MAXN];

    public static int n;

    public static void build() {
        for (int i = 0; i <= n; i++) {
            father[i] = i;
        }
    }

    public static int find(int i) {
        if (i != father[i]) {
            father[i] = find(father[i]);
        }
        return father[i];
    }

    public static boolean isSameSet(int x, int y) {
        return find(x) == find(y);
    }

    public static void union(int x, int y) {
        father[find(x)] = find(y);
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            n = (int) in.nval;
            build();
            in.nextToken();
            int m = (int) in.nval;
            for (int i = 0; i < m; i++) {
                in.nextToken();
                int z = (int) in.nval;
                in.nextToken();
                int x = (int) in.nval;
                in.nextToken();
                int y = (int) in.nval;
                if (z == 1) {
                    union(x, y);
                } else {
                    out.println(isSameSet(x, y) ? "Y" : "N");
                }
            }
        }
        out.flush();
        out.close();
        br.close();
    }

}

三.情侣牵手

题目：情侣牵手

算法原理

  • 数据结构部分
    • father数组：用于构建并查集的数据结构，表示元素之间的关系。这里father[i]初始表示i的父节点，在初始构建（build函数）时，每个元素的父节点是它自己，即每个元素是一个单独集合的代表。
    • sets变量：用于记录当前集合的数量。初始时，集合数量为n / 2，因为有n / 2对情侣，即n / 2个初始独立的集合。
  • 构建并查集（build函数）
    • 对于给定的m（这里m = n / 2），函数遍历从0到m - 1的每个元素，将其father设置为自己，表示每个元素是一个单独的集合，并且将sets初始化为m，代表初始的集合数量。
  • 查找操作（find函数）
    • 目的是找到给定元素所在集合的代表元素。
    • 如果i不等于father[i]，说明i不是所在集合的代表元素，通过递归调用find函数找到father[i]的代表元素，然后将father[i]直接指向这个代表元素，实现路径压缩，以提高后续查询效率。最后返回找到的代表元素father[i]。
  • 合并操作（union函数）
    • 首先通过find函数找到x和y的代表元素fx和fy。
    • 如果fx和fy不相等，说明x和y属于不同的集合，此时将fx的父节点设置为fy，表示将x所在的集合合并到y所在的集合中，并且集合数量sets减1，因为合并后集合数量减少了一个。
  • 主函数（minSwapsCouples）
    • 首先确定情侣对数n = row.length，然后构建并查集（build(n / 2)）。
    • 接着遍历座位数组row，每两个座位一组（i和i + 1），将对应的情侣编号（row[i] / 2和row[i + 1] / 2）进行合并操作（union）。
    • 最后，最少交换次数等于初始情侣对数（n / 2）减去最终的集合数量（sets）。这是因为每成功合并一对情侣（减少一个集合），就意味着减少了一次交换的需求，最终剩下的集合数量就是没有配对成功的情侣对数，用总的情侣对数减去它就是最少交换次数。

代码实现

// 情侣牵手
// n对情侣坐在连续排列的 2n 个座位上，想要牵到对方的手
// 人和座位由一个整数数组 row 表示，其中 row[i] 是坐在第 i 个座位上的人的ID
// 情侣们按顺序编号，第一对是 (0, 1)，第二对是 (2, 3)，以此类推，最后一对是 (2n-2, 2n-1)
// 返回 最少交换座位的次数，以便每对情侣可以并肩坐在一起
// 每次交换可选择任意两人，让他们站起来交换座位
// 测试链接 : https://leetcode.cn/problems/couples-holding-hands/
public class Code03_CouplesHoldingHands {

    public static int minSwapsCouples(int[] row) {
        int n = row.length;
        build(n / 2);
        for (int i = 0; i < n; i += 2) {
            union(row[i] / 2, row[i + 1] / 2);
        }
        return n / 2 - sets;
    }

    public static int MAXN = 31;

    public static int[] father = new int[MAXN];

    public static int sets;

    public static void build(int m) {
        for (int i = 0; i < m; i++) {
            father[i] = i;
        }
        sets = m;
    }

    public static int find(int i) {
        if (i != father[i]) {
            father[i] = find(father[i]);
        }
        return father[i];
    }

    public static void union(int x, int y) {
        int fx = find(x);
        int fy = find(y);
        if (fx != fy) {
            father[fx] = fy;
            sets--;
        }
    }

}

四.相似字符串组

题目：相似字符串组

算法原理

  • 数据结构
    • father数组：用于构建并查集，father[i]表示第i个字符串在并查集中的父节点，初始时每个字符串的父节点是它自己，即每个字符串是一个单独集合的代表。
    • sets变量：用于记录当前的集合数量，初始化为字符串的总数n。
  • 构建并查集（build函数）
    • 对于给定的字符串数量n，函数遍历从0到n - 1的每个索引。
    • 将father[i]设置为i，表示每个字符串初始为独立的集合，并且将sets设置为n，代表初始有n个集合。
  • 查找操作（find函数）
    • 查找操作的目的是找到给定字符串索引i所在集合的代表元素。
    • 如果i不等于father[i]，说明i不是所在集合的代表元素，通过递归调用find函数找到father[i]的代表元素，然后将father[i]直接指向这个代表元素，实现路径压缩，这有助于提高后续查找操作的效率。最后返回找到的代表元素father[i]。
  • 合并操作（union函数）
    • 首先通过find函数找到x和y的代表元素fx和fy。
    • 如果fx和fy不相等，说明x和y属于不同的集合，此时将fx的父节点设置为fy，表示将x所在的集合合并到y所在的集合中，并且集合数量sets减1，因为合并后集合数量减少了一个。
  • 计算相似字符串组数量（numSimilarGroups函数）
    • 首先获取字符串的数量n和每个字符串的长度m。
    • 构建并查集（build(n)）。
    • 然后进行双层循环，外层循环i从0到n - 1，内层循环j从i + 1到n - 1。
    • 对于每一对字符串strs[i]和strs[j]，如果它们不在同一个集合（find(i)!=find(j)），则计算它们不同字符的数量diff。
    • 如果diff为0（字符串相等）或者diff为2（满足相似字符串的条件），则将这两个字符串所在的集合合并（union(i, j)）。
    • 最后返回sets，即最终的集合数量，这个数量就是字符串组的数量。

代码实现

// 相似字符串组
// 如果交换字符串 X 中的两个不同位置的字母，使得它和字符串 Y 相等
// 那么称 X 和 Y 两个字符串相似
// 如果这两个字符串本身是相等的，那它们也是相似的
// 例如，"tars" 和 "rats" 是相似的 (交换 0 与 2 的位置)；
// "rats" 和 "arts" 也是相似的，但是 "star" 不与 "tars"，"rats"，或 "arts" 相似
// 总之，它们通过相似性形成了两个关联组：{"tars", "rats", "arts"} 和 {"star"}
// 注意，"tars" 和 "arts" 是在同一组中，即使它们并不相似
// 形式上，对每个组而言，要确定一个单词在组中，只需要这个词和该组中至少一个单词相似。
// 给你一个字符串列表 strs列表中的每个字符串都是 strs 中其它所有字符串的一个字母异位词。
// 返回 strs 中有多少字符串组
// 测试链接 : https://leetcode.cn/problems/similar-string-groups/
public class Code04_SimilarStringGroups {

    public static int MAXN = 301;

    public static int[] father = new int[MAXN];

    public static int sets;

    public static void build(int n) {
        for (int i = 0; i < n; i++) {
            father[i] = i;
        }
        sets = n;
    }

    public static int find(int i) {
        if (i != father[i]) {
            father[i] = find(father[i]);
        }
        return father[i];
    }

    public static void union(int x, int y) {
        int fx = find(x);
        int fy = find(y);
        if (fx != fy) {
            father[fx] = fy;
            sets--;
        }
    }

    public static int numSimilarGroups(String[] strs) {
        int n = strs.length;
        int m = strs[0].length();
        build(n);
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (find(i) != find(j)) {
                    int diff = 0;
                    for (int k = 0; k < m && diff < 3; k++) {
                        if (strs[i].charAt(k) != strs[j].charAt(k)) {
                            diff++;
                        }
                    }
                    if (diff == 0 || diff == 2) {
                        union(i, j);
                    }
                }
            }
        }
        return sets;
    }

}

五.岛屿数量

题目：岛屿数量

算法原理

  • 数据结构
    • father数组：用于构建并查集，father[i]表示第i个元素（这里对应网格中的陆地格子）在并查集中的父节点。初始时，每个陆地格子的父节点是它自己，表示每个陆地格子是一个单独集合的代表。
    • cols变量：用于记录网格的列数，方便在将二维坐标转换为一维索引时使用。
    • sets变量：用于记录当前的集合数量，初始时每一个独立的陆地格子都是一个集合，所以每发现一个'1'的格子，sets就加1。
  • 构建并查集（build函数）
    • 首先确定网格的列数cols = m，并将sets初始化为0。
    • 然后遍历二维网格，对于每个格子，如果它是陆地（board[a][b] == '1'），计算其在一维数组中的索引index = a * cols + b，将father[index]设置为index，表示这个格子是一个单独的集合，同时sets加1，表示发现了一个新的可能的岛屿。
  • 查找操作（find函数）
    • 查找操作的目的是找到给定元素所在集合的代表元素。
    • 如果i不等于father[i]，说明i不是所在集合的代表元素，通过递归调用find函数找到father[i]的代表元素，然后将father[i]直接指向这个代表元素，实现路径压缩，这有助于提高后续查找操作的效率。最后返回找到的代表元素father[i]。
  • 合并操作（union函数）
    • 这个函数用于合并两个集合。首先通过find函数分别找到坐标为(a, b)和(c, d)的陆地格子在并查集中的代表元素fx和fy。
    • 如果fx和fy不相等，说明这两个格子属于不同的集合，此时将fx的父节点设置为fy，表示将fx所在的集合合并到fy所在的集合中，并且集合数量sets减1，因为合并后集合数量减少了一个。
  • 计算岛屿数量（numIslands函数）
    • 首先获取网格的行数n和列数m，然后构建并查集（build(n, m, board)）。
    • 接着遍历二维网格，对于每个陆地格子（board[i][j] == '1'），检查其左边（j > 0 && board[i][j - 1] == '1'）和上边（i > 0 && board[i - 1][j] == '1'）是否也是陆地，如果是，则将它们所在的集合合并（union(i, j, i, j - 1)或union(i, j, i - 1, j)）。
    • 最后返回sets，即最终的集合数量，这个数量就是岛屿的数量，因为每个岛屿最终会被合并成一个集合。

代码实现

// 岛屿数量
// 给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量
// 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成
// 此外，你可以假设该网格的四条边均被水包围
// 测试链接 : https://leetcode.cn/problems/number-of-islands/
public class Code05_NumberOfIslands {

    // 并查集的做法
    public static int numIslands(char[][] board) {
        int n = board.length;
        int m = board[0].length;
        build(n, m, board);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == '1') {
                    if (j > 0 && board[i][j - 1] == '1') {
                        union(i, j, i, j - 1);
                    }
                    if (i > 0 && board[i - 1][j] == '1') {
                        union(i, j, i - 1, j);
                    }
                }
            }
        }
        return sets;
    }

    public static int MAXSIZE = 100001;

    public static int[] father = new int[MAXSIZE];

    public static int cols;

    public static int sets;

    public static void build(int n, int m, char[][] board) {
        cols = m;
        sets = 0;
        for (int a = 0; a < n; a++) {
            for (int b = 0, index; b < m; b++) {
                if (board[a][b] == '1') {
                    index = index(a, b);
                    father[index] = index;
                    sets++;
                }
            }
        }
    }

    public static int index(int a, int b) {
        return a * cols + b;
    }

    public static int find(int i) {
        if (i != father[i]) {
            father[i] = find(father[i]);
        }
        return father[i];
    }

    public static void union(int a, int b, int c, int d) {
        int fx = find(index(a, b));
        int fy = find(index(c, d));
        if (fx != fy) {
            father[fx] = fy;
            sets--;
        }
    }

}
并查集（带计数）-- 模板
等我，等我变的更好就去找你
06-08 571
题意： 在另一个宇宙，一个月有 N 天。多变的天气条件使得人们很恼火，终于，天气统计局产生了。它会对外发布 M 条信息，格式如下： X Y 表示第 X 天的天气和第 Y 天一样。 但民众并不满足于此，他们想知道有多少天的天气和第 X 天一样。 现在，作为一个聪明的程序员，你能帮他们解决这个问题吗？ 题解： 给并查集加上计数功能 #include&amp;amp;lt;cstdio&amp;amp;gt; using...
Python 必备面试基础知识-3
weixin_45722061的博客
10-09 789
今天继续分享 Python 相关的面试题，你准备好了嘛！ 网络编程篇 1. 简述 OSI 七层协议 是网络传输协议，人为的把网络传输的不同阶段划分成不同的层次。 七层划分为：应用层、表示层、会话层、传输层、网络层、数据链路层、物理层。 五层划分为：应用层、传输层、网络层、数据链路层、物理层。 物理层：网线，电缆等物理设备 数据链路层：Mac 地址 网络层：IP 地址 传输层：TCP，U...
并查集算法模板
仙女的博客
08-07 436
并查集通过一个一维数组来实现，它的本质是维护一个森林，刚开始的时候，森林的每个点都是孤立的，也可以理解为每个点就是一棵只有一个节点的树，之后通过一些条件，逐渐将这些树合并成一棵大树。其实合并的过程就是“认爹”的过程。在“认爹”的过程中，要遵守“靠左”原则和“擒贼先擒王”的原则。在每次判断两个节点是否已经在同一棵树的时候（一棵树其实就是一个集合），也要注意必须求其根源，中间父亲节点是不能说明问题的，...
算法-并查集模版
jingyu_1的博客
07-26 198
并查集是一种非常精巧而实用的数据结构，它主要用于处理一些不相交集合的合并问题。一些常见的用途有连通子图、求最小生成树的。查找时，递归找祖宗，祖宗集合号等于本身时停止。回归时，把查找路径上的所有节点统一为祖宗的集合号。合并时，只需要把一个元素的祖宗集合号改为另一个元素的祖宗集合号。算法和求最近公共祖先（LCA）等。...
WordPress程序文件功能介绍（WP程序开发必备）
littlesmallless的博客
11-04 607
11．wp-admin/edit-form-advanced.php：定义管理页面的日志高级编辑形式管理，包括post.php。16．wp-admin/edit-page-form.php：定义管理模块页面的页面编辑，包括post.php和page-new.php。5.wp-admin/admin- header.php：定义了管理控制台的上半部分内容，包括菜单逻辑 （menu logic）的 menu-header.php文件。15．wp-mail.php：用来获取通过邮件提交的博文。
Linux网络管理必备：iproute2命令速查手册
以下是iproute2命令集的详细知识点： 1. 基本命令结构： - ip命令的基本格式为："ip [选项] 对象 {命令}"，其中对象可以是link、addr、route等，命令可以是add、delete、show等。 2. 网络接口管理： - 使用"ip ...
从入门到进阶，史上最全Python精华文章合集
m0_71327177的博客
07-24 1270
随后，文章深入分析了6种数据可视化类型，并给出了使用PythonMatplotlib的例子，实现了以下内容两种散点图，线图，柱状图，条形图和箱形图。这篇文章演示了这种机制是如何工作的，并给出了一个从真实网站中爬取数据的例子。这篇文章采用展示示例代码和视频的形式，讲解了八大机器学习算法线性回归，逻辑回归，决策树，支持向量机，K近邻，随机森林，K-Means聚类及主成分分析。“迭代器指的是可在其上迭代（循环）的对象，其作用是为数据抽象出一个容器，使其表现出与迭代对象类似的功能。...
算法面试必备-----数据库与SQL面试题
Avery123123的博客
09-03 2234
算法面试必备-----数据库与SQL面试题算法面试必备-----数据库与SQL面试题1、数据库理论问题问题：什么是数据库,数据库管理系统,数据库系统,数据库管理员?问题：什么是元组,码,候选码,主码,外码,主属性,非主属性？问题：主键和外键有什么区别?问题：数据库范式了解吗?问题：什么是存储过程?问题：drop、delete与truncate区别？问题：DML 语句和 DDL 语句区别：问题：数据库设计通常分为哪几步?问题：事务的ACID特性是什么？问题：并发事务带来哪些问题?延伸问题：不可重复度和幻读有什
并查集（算法+模板+讲解）
12-26
并查集（算法+模板+讲解）
教你学会并查集算法
Forever Young
06-08 689
并查集 并查集被很多OIer认为是最简洁而优雅的数据结构之一，主要用于解决一些元素分组的问题。它管理一系列不相交的集合，并支持两种操作： 合并（Union）：把两个不相交的集合合并为一个集合。 查询（Find）：查询两个元素是否在同一个集合中。 当然，这样的定义未免太过学术化，看完后恐怕不太能理解它具体有什么用。所以我们先来看看并查集最直接的一个应用场景：亲戚问题。 （洛谷P1551）亲戚 题目背景 若某个家族人员过于庞大，要判断两个是否是亲戚，确实还很不容易，现在给出某个亲戚关系图，求任意给出的两个人是
算法模版之并查集
habewow的博客
05-24 267
简介：并查集实质是一种树形的数据结构，一般用于处理一些不相交集合的合并及查询问题。在具体问题解决上，比如找公共祖先节点、检查图的连通性等等，用通俗点的语言来描述的话，例如一个帮派（有点社会呀），a的大哥是b，b的大哥是c，c的大哥是d，此时a、b、c、d互相是不认识的，假如发生了帮派争斗，b和d相遇了，为了不伤到自己人，他们两个就必须确定对方是不是自己人，这个时候，b就问自己的大哥c，d是哪根葱，...
并查集算法模板简记
qq_45841239的博客
07-11 196
并查集算法：并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这一类问题近几年来反复出现在信息学的国际国内赛题中，其特点是看似并不复杂，但数据量极大，若用正常的数据结构来描述的话，往往在空间上过大，计算机无法承受；即使在空间上勉强通过，运行的时间复杂度也极高，根本就不可能在比赛规定的运行时间（1～3秒）内计算出试题需要的结果，只能用并查集来描述。 并查集是一种树型的数据结构，用于处理
【算法模板】数据结构：并查集
最新发布
2303_80346267的博客
05-19 1113
存储每个集合，树上的每个节点都是一个元素，树根是集合的代表元素。这样一来，在合并两个集合时，只需连接两个树根(令其中一个树根为另一个树根的子节点，即。这种方法可以快速查询元素的归属集合，但在合并时需要修改大量元素的f值，效率很低。合并时，选择哪棵树的根节点作为新树的根节点会影响未来操作的复杂度。我们可以按照子树大小去合并，小的合并到大的，以免发生退化。为了具体实现并查集这种数据结构，我们首先需要定义集合的表示方法。在并查集中，我们采用“代表元”法，即为每个集合选择一个固定的元素，作为整个集合的“代表”。
【基础算法练习】并查集模板
Locky136的博客
02-01 600
并查集，C++
并查集（模板）
微凉的博客
03-07 287
package Test1; public class L9 { //并查集 public static void main(String[] args) { // TODO Auto-generated method stub } } class P { static int[] par = new int[1000];// 父亲 static int[] rank = n...
并查集的实现模板
weixin_45844836的博客
03-29 163
在题目中，如果是求 对什么合并，或者是图的连通区域的个数之类的，应该考虑使用并查集 下面我总结出一个并查集的模板 package 图论.并查集; import java.util.Arrays; /** * 并查集的实现 */ public class UF_Tree { /** * 根据顶点创建一个数组 * 数组索引对应顶点 值对应他的父节点 */ private int[] eleAndGroup; //计算并查集中分组的个数 pr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值