力扣技巧-并查集

原创 已于 2022-10-01 00:18:28 修改 · 445 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode #算法 #java

于 2022-09-30 01:01:52 首次发布
最小生成树

【题目】给定一个图的点集，边集和权重，返回构建最小生成树的代价。

输入：N = 2， conn = [[1, 2, 37], [2, 1, 17], [1, 2, 68]]

输出：17

class Solution {

  private long cost = 0;

  // 这里直接申请了足够多的内存

  private int[] F = null;

  // 并查集初始化

  // 注意点的编号是从1~n

  private void Init(int n) {

    F = new int[n+1];

    for (int i = 0; i <= n; i++) {

      F[i] = i;

    }

    cost = 0;

  }

  private int Find(int x) {

    if (x == F[x]) {

      return x;

    }

    F[x] = Find(F[x]);

    return F[x];

  }

  // 在合并的时候，需要加上代价

  private void Union(int x, int y, int pay) {

    if (Find(x) != Find(y)) cost += pay;

    F[Find(x)] = Find(y);

  }

  // 一共有n个点，编号从1~n

  // conn表示输入的边的集合

  // 每一项是一个三元组[点a, 点b, 需要费用c]

  public long Kruskal(int n, int m, int[][] conn) {

    Init(n);

    // 边集的排序

    Arrays.sort(conn, 0, m, new Comparator<int[]>() {

      public int compare(int[] a, int[] b) {

        return a[2] - b[2];

      }

    });

    // 顺次将边集添加到集合中

    for (int i = 0; i < m; i++) {

      Union(conn[i][0], conn[i][1], conn[i][2]);

    }

    return cost;

  }

}
例 2：帮派的数目

【题目】江湖上有 N 个人，编号从 [1 ~ N]，现在只能告诉你，其中两人是一个帮派的，请你输出帮派的数目。

输入：N = 4, [[1, 2], [2,3]]

输出：2

解释：一共有 4 个人，[1,2, 3] 成为一个帮派，[4] 独自成为一个帮派，那么一共有 2 个帮派。

int count = 0;

int[] F = null;

void Init(int n) {

  F = new int[n + 1];

  for (int i = 0; i <= n; i++) {

    F[i] = i;

  }

  count = n;

}

int Find(int x) {

  if (x == F[x]) {

    return x;

  }

  F[x] = Find(F[x]);

  return F[x];

}

void Union(int x, int y) {

  if (Find(x) != Find(y))

    count--;

  F[Find(x)] = Find(y);

}

int findGangNumber(int n, int[][] conn) {

  Init(n);

  int m = conn.length;

  for (int i = 0; i < m; i++) {

    Union(conn[i][0], conn[i][1]);

  }

  // 帮派里面帮主的个数

  return count;

}

延伸：如果将这里的每个点都当成一个“图”结构中的一个点，将两两成对的输入当成“图”结构中的边。那么问题就变成了求解图的连通域个数。

200. 岛屿数量
class Solution {

    private int[][] directions = new int[][]{
        {0, 1}, {1, 0}
    };
    private int[] F = null;
    private int count = 0;

    private void Init(int n) {
        F = new int[n];
        for (int i = 0; i < n; i ++) {
            F[i] = i;
        }
        count = n;
    }

    private int Find(int x) {
        if (x == F[x]) {
            return x;
        }
        F[x] = Find(F[x]);
        return F[x];
    }

    private void Union(int x, int y) {
        if (Find(x) != Find(y)) {
            count --;
        }
        F[Find(x)] = Find(y);
    }

    public int numIslands(char[][] grid) {

        final int m = grid.length;
        final int n = grid[0].length;

        Init(m * n);
        int blackNumber = 0;

        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                if ('1' == grid[i][j]) {
                    for (int d = 0; d < directions.length; d ++) {
                        int x = i + directions[d][0];
                        int y = j + directions[d][1];
                        if (x < 0 || x >= m || y < 0 || y >= n || '0' == grid[x][y]) {
                            continue;
                        }
                        Union(i * n + j, x * n + y);
                    }
                } else {
                    blackNumber ++;
                }
            }
        }

        return count - blackNumber;
    }
}
547. 省份数量
class Solution {

    private int[] F = null;
    private int count = 0;

    private void Init(int n) {
        F = new int[n];
        for (int i = 0; i < n; i ++) {
            F[i] = i;
        }
        count = n;
    }

    private int Find(int x) {
        if (x == F[x]) {
            return x;
        }
        F[x] = Find(F[x]);
        return F[x];
    }

    private void Union(int x, int y) {
        if (Find(x) != Find(y)) {
            count --;
        }
        F[Find(x)] = Find(y);
    }

    public int findCircleNum(int[][] isConnected) {

        final int n = isConnected.length;
        Init(n);

        for (int i = 0; i < n; i ++) {
            for (int j = i + 1; j < n; j ++) {
                if (1 == isConnected[i][j]) {
                    Union(i, j);
                }
            }
        }

        return count;
    }
}
839. 相似字符串组
class Solution {

    int count = 0;
    int[] F = null;

    private void Init(int n) {
        F = new int[n];
        for (int i = 0; i < n; i ++) {
            F[i] = i;
        }
        count = n;
    }

    private int Find(int x) {
        if (x == F[x]) {
            return x;
        }
        F[x] = Find(F[x]);
        return F[x];
    }

    private void Union(int x, int y) {
        if (Find(x) != Find(y)) {
            count --;
        }
        F[Find(x)] = Find(y);
    }

    private boolean check(String a, String b) {

        final int n = a.length();
        int[] aArr = new int[256];
        int[] bArr = new int[256];

        for (int i = 0; i < n; i ++) {
            aArr[a.charAt(i)] ++;
            bArr[b.charAt(i)] ++;
        }

        for (int i = 0; i < n; i ++) {
            if (aArr[i] != bArr[i]) {
                return false;
            }
        }

        int number = 0;
        for (int i = 0; i < n; i ++) {
            if (a.charAt(i) != b.charAt(i)) {
                number ++;
            }
            if (number > 2) {
                return false;
            }
        }

        return true;
    }

    public int numSimilarGroups(String[] strs) {
        final int n = strs.length;
        Init(n);
        for (int i = 0; i < n; i ++) {
            for (int j = i + 1; j < n; j ++) {
                if (check(strs[i], strs[j])) {
                    Union(i, j);
                }
            }
        }

        return count;
    }
}

虚拟点与虚拟边

上网的最小费用

【题目】园区里面有很多大楼，编号从 1~N。第 i 大楼可以自己花钱买路由器上网，费用为 cost[i-1]，也可以从别的大楼拉一根网线来上网，比如大楼 a 和大楼 b 之间拉网线的费用为 c，表示为一条边 [a, b, c]。输入为每个大楼自己买路由器和拉网线的费用，请问，让所有大楼都能够上网的最小费用是多少？上网具有联通性，只要与能够上网的大楼连通，即可上网。

输入：cost = [1, 2, 3], edges = [[1,2,100], [2,3,3]]

输出：6

题目参考：https://kaiwu.lagou.com/course/courseInfo.htm?courseId=685#/detail/pc?id=6696

class Solution {

  private int[] F = null;

  private int totalCost = 0;

  // 注意，编号是从1 ~ n

  private void Init(int n) {

    F = new int[n + 1];

    for (int i = 0; i <= n; i++) {

      F[i] = i;

    }

    totalCost = 0;

  }

  private int Find(int x) {

    if (x == F[x]) {

      return x;

    }

    F[x] = Find(F[x]);

    return F[x];

  }

  private void Union(int x, int y, int pay) {

    if (Find(x) != Find(y)) {

      totalCost += pay;

    }

    F[Find(x)] = Find(y);

  }

  // N 表示结点数目

  // cost[i-1]表示结点i自己买路由器的代价

  // es[x] = [a, b, c]表示大楼a,b之间拉网线的费用

  // 输出所有大楼通网的最小费用

  public int minCostToSupplyWater(int N, int[] cost, int[][] es) {

    // 初始化并查集

    Init(N);

    // 每个结点都要自己买路由器，那么我们可以认为这样

    // 0号楼已经有网络了，可以用0费用上网

    // i号楼与0号楼拉网线，需要的费用是cost[i-1]

    // 那么这里就多了N条边

    int[][] conn = new int[es.length + N][3];

    for (int i = 0; i < es.length; i++) {

      conn[i][0] = es[i][0];

      conn[i][1] = es[i][1];

      conn[i][2] = es[i][2];

    }

    int to = es.length;

    for (int i = 1; i <= N; i++) {

      conn[to][0] = 0;

      conn[to][1] = i;

      conn[to][2] = cost[i - 1];

      to++;

    }

    // 接下来采用Krukal最小生成树算法

    Arrays.sort(conn, new Comparator<int[]>() {

      public int compare(int[] a, int[] b) {

        return a[2] - b[2];

      }

    });

    for (int i = 0; i < conn.length; i++) {

      Union(conn[i][0], conn[i][1], conn[i][2]);

    }

    return totalCost;

  }

}
远腾飞
关注
力扣 547. 省份数量-并查集解法
我思故我在
12-08 476
地址：力扣 题目： 有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。 省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。 给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。 思路： 并查集解决思...
数据结构与算法：学习并查集
_xiaolin_
02-01 2636
并查集一般都不怎么用到，甚至听都没怎么听到过这么一个数据结构，写这篇文章是源自于我在刷力扣第130. 被围绕的区域这道题的时候涉及到并查集的使用，大家如果没做过可以去做一下，程序员闲的时候刷刷算法题是非常有意义的事情。原本这道题使用深度优先遍历(DFS)和广度优先遍历(BFS)就可以解决，但是执行时间才超过百分之五十多，这让我有点不服，我想看下使用并查集看下执行时间需要多久，所以想...
力扣并查集
nameofcsdn的博客
01-29 1199
。。
力扣-并查集
Dream is possible
06-26 617
通过使用不同的按秩合并，可以知道节点的个数，和树的高度，增加一个变量n则可以知道进行了多少次连接操作.根据根节点的个数(根节点指向自己)可以求出分组的个数。
力扣——并查集算法系列
zzs92987的博客
04-22 923
否则的话就要把这两棵子树连到一起，最简单的做法就是直接把 ru 连到 rv 下面，当作它的子结点，那么就需要更新 f[ru] = rv。那么我们定义查找根结点函数 find(u) ，如果 u = f[u] ，那么不用找了，它自己就是根结点。最后做一步路径压缩的优化，把根结点当作 u 的父结点： f[u] = find(f[u])。这样下次再查找的时候，路径长度就变为了 1 ，一步就能找到根结点了。合并两棵子树的时候，为了使得合并后的子树高度尽量小，需要把高度小的那棵子树接在高度高的那棵下面，当作儿子。
力扣并查集例题
03-30
运用带权版并查集技巧检测何时形成闭环从而定位错误链接位置。 --- ```python class UnionFind: def __init__(self, n): self.parent = list(range(n)) def find(self, p): while p != self.parent[p]: ...
掌握并查集算法：力扣1198题与HDOJ实践解析
资源摘要信息:"LeetCode第1198题涉及到并查集这一数据结构，并要求解题者具有图论的知识背景。HDOJ（HDU）即杭州电子科技大学在线评测系统，是一个常用于竞赛编程和算法练习的平台，与LeetCode一样，它提供了大量的...
计算机算法与数据结构_LeetCode力扣刷题_树状数组线段树并查集动态规划贪心算法双指针滑动窗口_笔试面试高频考点解析与模板代码实战训练项目_旨在帮助程序员系统掌握算法知识体系_.zip
最新发布
05-05
本文档集涉及了多种算法与数据结构的深入解析，特别是针对在各种笔试与面试中频繁出现的考点，如树状数组、线段树、并查集、动态规划、贪心算法、双指针技术、滑动窗口等。这些内容不仅覆盖了理论知识，还包括了实战...
力扣编程题解决方案集：LCSolutions-dev
LeetCode 本身是一个开源社区，任何人可以访问并提交解决方案。同时，解决方案的共享可以帮助他人学习和提高。 4. 压缩包子文件的文件名称列表： LCSolutions-dev 表明了这个解决方案可能是针对开发者版本的 ...
并查集实现家谱关系管理与数据示例
并查集（Union-Find Set），又称不相交集合（Disjoint Set）数据结构，是一种用于高效处理集合合并与元素归属查询问题的经典算法工具。在“家谱数据”这一具体应用场景中，并查集被广泛用于模拟和维护家族成员之间的...
力扣解题思路：并查集
qq_39879315的博客
07-28 999
684. 冗余连接 思路：有一系列的边连成的图，找出一条边，移除它之后该图能够成为一棵树。 Input: [[1,2], [1,3], [2,3]] Output: [2,3] Explanation: The given undirected graph will be like this: 1 / \ 2 - 3 如果移除一条边可以成为一棵树那就意味着这个图存在环路，那么移除这个环的任意边即可（题目要求是最后一条边），所以我们可以使用并查集来记录每个节点的最前前驱节点，也就是父节点，如果两个节点的
并查集——力扣990.等式方程的可满足性
qq_41809369的博客
06-09 322
并查集——力扣990.等式方程的可满足性 并查集 ​ 首先先从一个题目来看看背景。990.等式方程的可满足性 ​ 题目中讲到给出 “==” 和 “!=” 来表示两个变量之间的关系，有等于和不等于两种关系。一看到题目呢，大家应该都有一个共同的解题思路，将所有相等的变量放在一起，组成一个集合，然后依次去判断不等的向量是否在同一个集合中，如果在同一个集合中则表明发生冲突，无法分配整数，如果不在同一个集合中，则表明是没有问题的。 ​ 通过上面的分析，我们可以发现，并查集由合并操作、查找操作和集合组成。但是我们怎么知
力扣刷题（684. 冗余连接）并查集
yanzhe1的博客
08-12 318
力扣刷题（684. 冗余连接）并查集
力扣leetcode刷题：并查集相关题目
代码届的小白的博客
01-31 3250
这里写目录标题并查集的思想与介绍力扣721.账户合并题目描述题目解读 方法：哈希表+并查集详细代码和注释839.相似字符串组题目描述题目解读 方法：并查集详细代码和注释 并查集的思想与介绍 可以查看这片文章！ https://blog.youkuaiyun.com/weixin_42305672/article/details/112699785 力扣721.账户合并 题目描述 给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是 名称
【力扣分模块练习】并查集及其变型
abyss_miracle的博客
01-11 336
1202. 交换字符串中的元素 给你一个字符串 s，以及该字符串中的一些「索引对」数组 pairs，其中 pairs[i] = [a, b] 表示字符串中的两个索引（编号从 0 开始）。 你可以 任意多次交换 在 pairs 中任意一对索引处的字符。 返回在经过若干次交换后，s 可以变成的按字典序最小的字符串。 示例 1: 输入：s = “dcab”, pairs = [[0,3],[1,2]] 输出：“bacd” 解释： 交换 s[0] 和 s[3], s = “bcad” 交换 s[1] 和 s[2],
【力扣】通俗易懂并查集·月整理
阿栗要努力成为ai大神
01-30 323
更复杂的并查集内容在https://zhuanlan.zhihu.com/p/93647900/ 我们只需要知道并查集能帮助我们做什么，和代码框架解读 一.并查集通俗理解 通俗来说就是用一个二维矩阵，起初大家都是孤立的 然后某个节点不断得进行势力扩张，合并其他节点，比如初始矩阵如下： [[0,1,2] [3,4,5] [6,7,8]] 然后进行merge 操作，比如merge(2,1)，merge(2,4)，merge(2,7)，merge(2,8)那么矩阵变成 [[0,2,2] [3,2,5] [6,2,
力扣刷题-128.最长连续序列、并查集
编程猿来如此
06-12 677
一．并查集   顾名思义：并：就是合并，查：就是查找，集：就是集合。并查集是一种树形的数据结构，支持以下两种操作： 查找：确定某个元素处于哪个子集 合并：将两个子集合并成一个集合 初始化 集合就是一些具有相同特征的元素构成的圈子，然后用其中某个元素作为整个圈子的代表。 如上图所示：初始的时候每个元素各自构成一个集合，自己为自己代言。 合并 可以用树形结构来表示整个集合，每个元素代表一个节点，用根节点代表整个集合。合并两个元素就是对两个元素所在的集合进行合并，即直接把一个集合的根节点作为另外一个集合根
并查集与力扣128
weixin_43868966的博客
03-27 410
并查集 应用： 两个集合（图）之间的连通性 场景： 两类元素，属于不同的集合，彼此之间不清楚自己所属的集合 并查集漫画 设计方式： 每个集合各自的元素都使用类似指针的方式连通在一起； 并查集类UnionFind维护一个parent[]数组，记录自己上一个元素的位置，即parent[i] = last; 根节点的parent[i] == i,即自己 这样判别两个元素是否在一个集合，只需要***找到各自的根节点是否相同即可*** 代码实现【以最简单的int哈希表为例】： class U
990. 等式方程的可满足性
Justdoforever的博客
03-18 254
等式方程的可满足性 给定一个由表示变量之间关系的字符串方程组成的数组，每个字符串方程 equations[i] 的长度为 4，并采用两种不同的形式之一：“a==b” 或 “a!=b”。在这里，a 和 b 是小写字母（不一定不同），表示单字母变量名。 只有当可以将整数分配给变量名，以便满足所有给定的方程时才返回 true，否则返回 false。 示例 1： 输入：[“a==b”,“b!=a”] 输出：false 解释：如果我们指定，a = 1 且 b = 1，那么可以满足第一个方程，但无法满足第二个方程。.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值