LeetCode题库：并查集问题（Python语言实现）

最新推荐文章于 2024-08-21 18:15:47 发布
最新推荐文章于 2024-08-21 18:15:47 发布
阅读量1.3k 收藏 14
点赞数 3
分类专栏： LeetCode刷题笔记 文章标签： 数据结构 python leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44064553/article/details/112303225
版权
本文详细介绍了并查集这一数据结构在LeetCode中的常见应用，包括等式方程的可满足性、连通网络的操作次数、冗余连接、最长连续子序列、移除最多的同行同列的石头以及省份数量问题的解决方案。通过具体题目实例，展示了并查集的模板代码及其在解决实际问题中的变型，帮助读者深入理解并查集的使用技巧。
摘要由CSDN通过智能技术生成

并查集相关知识

并查集常用模板

class UnionSet:
    def init_tree(self,n):
        self.fa = [i for i in range(n)] # 必要，记录根节点，也可能是字典形式
        self.cnt = collections.defalutdict(lambda :1) # 不一定必要，用于计算树的高度
    
    def find(self,x): # 寻找根节点，并状态压缩
        while self.fa[x]!=x:
            x= self.fa[x]
        return x

    def union(self,u,v): # 合并
        ru = self.find(u)
        rv = self.find(v)
        if ru == rv:
            return 
        self.fa[ru] = rv
        return

1、LeetCode900、等式方程的可满足性

题目描述

题目描述

题解思路

  1. 等式具有传递性，将a-z映射成0-25一共26个数字
  2. 遍历所有的等式，将等式左右两边的字母（已经转换成数字了）连通起来
  3. 遍历所有的不等式，如果等式左右两边字母的根节点一样，与不等这个条件矛盾，返回False
  4. 遍历结束，返回True

python代码

class Solution:
    # 并查集，等式具有传递性
    def init_tree(self,n):
        self.fa = [i for i in range(n)]
    
    def find(self,x):
        while self.fa[x]!=x:
            x= self.fa[x]
        return x

    def union(self,u,v):
        ru = self.find(u)
        rv = self.find(v)
        if ru == rv:
            return 
        self.fa[ru] = rv
        return 

    def equationsPossible(self, equations: List[str]) -> bool:
        self.init_tree(26) # 初始化并查集
        for s in equations: # 遍历等式
            if s[1] == '=': 
                index1 = ord(s[0])-ord('a')
                index2 = ord(s[3])-ord('a')
                self.union(index1,index2)
        for s in equations: # 遍历不等式
            if s[1] == '!':
                index1 = ord(s[0])-ord('a')
                index2 = ord(s[3])-ord('a')
                if self.find(index1) == self.find(index2):
                    return False
        return True

2、LeetCode1319、连通网络的操作次数

题目描述

题目描述

题解思路

  1. 总共需要n-1个线缆
  2. 如果两个计算机的根节点一样，可以节省一根线
  3. 判断还需要的线缆数目和省下来的线缆的数目，如果后者大，返回前者，否则返回-1

Python代码

class Solution:

    def init_tree(self,n):
        self.fa = [i for i in range(n)]
    
    def find(self,x):
        while self.fa[x]!=x:
            x= self.fa[x]
        return x

    def union(self,u,v):
        ru = self.find(u)
        rv = self.find(v)
        if ru == rv:
            return 
        self.fa[ru] = rv
        return 

    def makeConnected(self, n: int, connections: List[List[int]]) -> int:
        # 总共需要n-1个线缆
        # 如果两个计算机的跟节点一样，可以省一根线,假设省x根
        # if (n-1)-(len(connections)-x)>x:return -1 else return 前面的部分
        self.init_tree(n)
        x = 0
        for s in connections:
            if self.find(s[0])!=self.find(s[1]):
                self.union(s[0],s[1])
            else:
                x+=1
        res = (n-1)-(len(connections)-x)
        return res if res<=x else -1

可以看到基本上并查集部分的模板代码是几乎不怎么需要改变的！！！

3、LeetCode684、冗余连接

题目描述

题目描述

题解思路

  1. 遍历节点，如果一条边的两个顶点的根节点不一样，就进行合并
  2. 如果一样，说明已经形成环了，直接返回（如示例1，节点2和3的根节点都是1，而[2,3]表示的又是2,3之间有边，所以已经成环了）

Python代码

class Solution:
       
    # 并查集
    # 遍历节点，如果一条边的两个顶点的父节点不一样，就合并；
    # 如果一样，说明形成环了，直接返回

    def init_tree(self,n):
        self.fa = [i for i in range(n)]
    
    def find(self,x):
        while self.fa[x]!=x:
            x= self.fa[x]
        return x

    def union(self,u,v):
        ru = self.find(u)
        rv = self.find(v)
        if ru == rv:
            return 
        self.fa[ru] = rv
        return 

    def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
        n = len(edges)
        self.init_tree(n)
        for i in range(n): # 调用find函数要注意find中的索引应该是[0,len(self.fa)-1]
            if self.find(edges[i][0]-1) != self.find(edges[i][1]-1): # 因为self.fa=[1,2,3]，但是索引从0开始
                self.union(edges[i][0]-1,edges[i][1]-1)
            else:
                return edges[i]
        return -1

4、LeetCode128、最长连续子序列

题目描述

题目描述

题解思路

  1. 除了要初始化根节点以外，还要初始化每个根节点对应的树的高度
  2. 并查集的连接函数需要修改一下，即要有具体的返回值，如果两棵树的根节点一样，就将两个数的高度加起来，并返回
  3. 遍历数组，迭代更新当前数与（当前数+1）的连接结果

Python代码

class Solution:
    def init_tree(self,nums):
        self.fa = {num:num for num in nums}
        self.cnt = collections.defaultdict(lambda:1)
    
    def find(self,x):
        while self.fa[x]!=x:
            x = self.fa[x]
        return x

    def union(self,u,v):
        if v not in self.fa:
            return 1
        ru = self.find(u)
        rv = self.find(v)
        if ru == rv:
            return self.cnt[ru]
        self.fa[ru] = rv
        self.cnt[rv]+=self.cnt[ru]
        return self.cnt[rv]
        
    def longestConsecutive(self, nums: List[int]) -> int:
        # 方法1、模拟
        # nums = list(set(nums))
        # nums.sort()
        # index = 0
        # count = 1 # 记录连续序列长度
        # res = 0 # 记录结果
        # while index<len(nums):
        #     if nums[index]+1 in  nums:
        #         count+=1
        #     else:
        #         count = 1 # 不连续，就重头开始计数
        #     res = max(res,count)
        #     index+=1
        # return res

        # 方法2，并查集
        
        n = len(nums)
        res = 0
        self.init_tree(nums)
        for num in nums:
            res = max(res,self.union(num,num+1))
        return res

注意到这里初始化并查集的根节点，使用的是哈希表而不是数组，因为给定的数字数组并不是连续的

5、LeetCode947、移除最多的同行同列的石头

题目描述

题目描述
提示：

1 <= stones.length <= 1000
0 <= xi, yi <= 10**4
不会有两块石头放在同一个坐标点上

题解思路

  1. 可以给nums中每个坐标定义一个索引，然后如果两个坐标含有相同的横纵坐标，就连通两个坐标
  2. 最后查看有几个独立的并查集集合，也就是最终留下的坐标个数x
  3. 返回len(nums)-x即可

Python代码

class Solution:
    def init_tree(self,n):
        self.fa = [i for i in range(n)]
    
    def find(self,x):
        while self.fa[x]!=x:
            x= self.fa[x]
        return x

    def union(self,u,v):
        ru = self.find(u)
        rv = self.find(v)
        if ru == rv:
            return 
        self.fa[ru] = rv
        return 

    def removeStones(self, stones: List[List[int]]) -> int:
        self.init_tree(len(stones))
        for i in range(len(stones)-1):
            for j in range(i+1,len(stones)):
                if stones[i][0]==stones[j][0] or stones[i][1]==stones[j][1]:
                    self.union(i,j)
        hashmap = {}
        for i in range(len(stones)):
            hashmap[i] = self.find(i)
        return len(stones)-len(set(hashmap.values()))

但是此种方法时间复杂度较高，需要两次遍历，还可以继续优化
实际上，只需要将每个点的横纵坐标连通起来就可以了，但是并查集是一个一维的数据结构，横坐标=2，显然和纵坐标=2是不一样的2，于是为了区分，考虑到横纵坐标的取值范围，将纵坐标+1000即可

class Solution:
    def init_tree(self,n):
        self.fa = [i for i in range(n)]
    
    def find(self,x):
        while self.fa[x]!=x:
            x= self.fa[x]
        return x

    def union(self,u,v):
        ru = self.find(u)
        rv = self.find(v)
        if ru == rv:
            return 
        self.fa[ru] = rv
        return 

    def removeStones(self, stones: List[List[int]]) -> int:
        self.init_tree(20000)
        for x,y in stones:
            self.union(x,y+10000)  # 并查集是一维的，比如第二行和第二列可能难以区分，故将列+10000转换为一维的
        return len(stones)-len({self.find(x) for x,y in stones}) # {}表示集合，自动去重

6、LeetCode547、省份数量

题目描述

题目描述

题解思路

  1. 连接相连的两个城市
  2. 遍历数组，没连接成功一个，独立的省份数量就少一个

Python代码

class Solution:
    # 并查集
    def init_tree(self, n) -> None:
        self.fa = [i for i in range(n)] # 记录每个节点的父节点
    
    def find(self, x):
        while self.fa[x] != x:
            x = self.fa[x]
        return x

    def union(self, u, v):
        ru = self.find(u)
        rv = self.find(v)
        if ru == rv:
            return False
        self.fa[ru] = rv # 将ru的根设为rv
        return True

    def findCircleNum(self, M: List[List[int]]) -> int:
        n = len(M)
        self.init_tree(n)
        res = n
        for i in range(n):
            for j in range(i + 1, n):
                if M[i][j] == 1 and self.union(i, j):
                    res -= 1
        return res

这里不同的是连接函数中，返回了True和False
带权重的并查集不会，懒得看，看不懂，暂且PASS

仙童木卫四
关注
专栏目录
数据结构-第六期——并查集（Python）
荷叶田田的博客
01-09 2398
数据结构——并查集
LeetCode刷题记录--- 微软企业题库
weixin_43646592的博客
12-30 1514
😄 今天是2022年10月30号，我开始了LeetCode的《微软企业题库》专题 刷题！
python 并查集_python实现并查集
weixin_39702335的博客
12-10 242
以下为本人学习并查集的体会与总结。并查集概念并查集也被称为不相交集数据结构。顾名思义，并查集主要操作是合并与查询，它是把初始不相交的集合经过多次合并操作后合并为一个大集合，然后可以通过查询判断两个元素是否已经在同一个集合中了。并查集的应用场景一般就是动态连通性的判断，例如判断网络中的两台电脑是否连通，在程序中判断两个变量名是否指向同一内存地址等。并查集的实现并查集的存储结构并查集逻辑上是森林，我们...
算法急救LeetCode62题-python版（3）/ 栈与队列
最新发布
come_closer的博客
08-21 810
算法急救LeetCode62题-python版（3）/ 栈与队列
LeetCode684. 冗余连接(并查集，python）
rosefun96的博客
09-04 404
1. 题目 在本问题中, 树指的是一个连通且无环的无向图。 输入一个图，该图由一个有着N个节点 (节点值不重复1, 2, …, N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。 结果图是一个以边组成的二维数组。每一个边的元素是一对[u, v] ，满足 u < v，表示连接顶点u 和v的无向图的边。 返回一条可以删去的边，使得结果图是一个有着N个节点的树。如果有多个答案，则返回二维数组中最后出现的边。答案边 [u, v] 应满足相同的格式 u <
并查集（python代码实现）
记录知识，学习分享
06-10 4519
并查集是一种树型的数据结构，用于处理一些不相交集合的合并与查询问题。主要两种操作（合并和查询）：实现： 一个集合构建一棵树，任选一个元素作为该集合的根节点； 建立pre数值记录每个元素的父节点，pre[当前节点]为父节点，根节点的父节点为自己本身。 给定元素关系，将一个集合的树变为另一个集合的子（将一个集合的根节点的父节点改为另一个集合的根节点），如：B的根节点等于A的根节点，这就可以将A和B两棵树合并为一棵树。 判断两个元素是否在同一个集合中： 从该
Leetcode-并查集
albyc22660的专栏
08-20 251
200.岛屿数量https://leetcode-cn.com/problems/number-of-islands/ 给定一个由'1'（陆地）和 '0'（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。 示例: 输入: 11000 11000 00100 00011 输...
leetcode题库-LeetCode:力扣题库
06-29
6. 并查集与图论：用于处理连接问题，如判定两个元素是否在同一集合中，或找出图的最小生成树（Prim算法、Kruskal算法）。 7. 排序与堆：快速排序、归并排序、堆排序等经典排序算法，以及大顶堆、小顶堆的应用。 8...
leetcode题库-like:用于收集开发者常用的一些链接--史上最强收藏夹
06-29
leetcode题库 史上最强收藏夹 链接导航 常用链接 全球最大的同性交友社区 面向全球的问答社区，可能你遇到的问题，都有解决 史上最强中文社区 常用工具类 包含json格式化，css格式化，等诸多工具 一个神奇的网站，...
leetcode323. 无向图中连通分量的数目
12-15
解决这个问题的一个经典算法是**并查集（Disjoint Set）**，它是一种数据结构，用于高效地维护集合的分拆和合并操作。在并查集中，每个节点都有一个父节点，根节点的父节点是它自己。通过查找操作可以找到任意节点的...
华为od机试真题： 精准核酸检测 （Python）
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
07-24 675
华为od机试真题： 精准核酸检测 （Python） 为了达到新冠疫情精准防控的需要，为了避免全员核酸检测带来的浪费，需要精准圈定可能被感染的人群。 现在根据传染病流调以及大数据分析，得到了每个人之间在时间、空间上是否存在轨迹的交叉。 现在给定一组确诊人员编号(X1,X2,X3...Xn) 在所有人当中，找出哪些人需要进行核酸检测，输出需要进行核酸检测的人数。（注意:确诊病例自身不需要再做核酸检测) 需要进行核酸检测的人，是病毒传播链条上的所有人员，即有可能通过确诊病例所能传播到的所有人。 例如:A是
leetcode-并查集
MaYingColdPlay的博客
06-04 778
leetcode-广度优先遍历/图/并查集_MaYingColdPlay的博客-CSDN博客 5941 找出知道秘密的所有专家 class UnionFind: def __init__(self, n): self.count = n self.parent = [i for i in range(n)] self.rank = [0] * n def find(self, i): if self...
1029-除法求值
LINZEYU666的博客
03-17 374
题目如下 给你一个变量对数组 equations 和一个实数值数组 values 作为已知条件，其中 equations[i] = [Ai, Bi] 和 values[i] 共同表示等式 Ai / Bi = values[i] 。每个 Ai 或 Bi 是一个表示单个变量的字符串。 另有一些以数组 queries 表示的问题，其中 queries[j] = [Cj, Dj] 表示第 j 个问题，请你根据已知条件找出 Cj / Dj = ? 的结果作为答案。 返回所有问题的答案 。如果存在某个无法确定的答案，则
LeetCode-并查集
码来-陈平安的博客
10-26 191
并查集 应用：判断两个节点是否连通，查找两个节点的最近公共节点；找出图成环的最后加入的一条边（最小生成树）。
leetcode 并查集
weixin_41964962的博客
03-05 800
并查集 并查集是一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。有一个联合-查找算法（Union-find Algorithm）定义了两个用于此数据结构的操作： Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。 Union：将两个子集合并成同一个集合。 由于支持这两种操作，一个不相交集也常被称为联合-查找数据结构（Union-fi...
Leetcode---并查集
sgh666666的博客
04-26 342
简介 并查集是一种数据结构，一般它处理的是图(其实是解决无向图的)的连通分量问题，但是当并查集的根节点可以维护更多的信息时，并查集可以解决范围更广的基于无向图连通分量的问题。做了这么多并查集的题目后，我感觉并查集就是解决有关物与物之间的关系问题的数据结构且这种关系还必须是可传递的关系，所以一般遇到这种问题可以先尝试用并查集解决。 并查集操作比较简单，主要是理解...
并查集--leetcode
Lavender-csdn的博客
09-12 309
并查集作用： 1、合并两个集合 2、判断两个点是否在同一个集合中 模板： // 找到父节点 public static int find(int x) { if(p[x]!=x) p[x] = find(x); return p[x]; } 1、547. 省份数量 以下为java代码： class Solution { static int[] p; public int findCircleNum(int[][] isConnected) { in
我的力扣算法684-冗余连接
一坠的博客
01-13 278
ok 看题： 在本问题中, 树指的是一个连通且无环的无向图。 输入一个图，该图由一个有着N个节点 (节点值不重复1, 2, …, N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。 结果图是一个以边组成的二维数组。每一个边的元素是一对[u, v] ，满足 u < v，表示连接顶点u 和v的无向图的边。 返回一条可以删去的边，使得结果图是一个有着N个节点的树。如果有多个答案，则返回二维数组中最后出现的边。答案边 [u, v] 应满足相同的格式 u &lt
LeetCode并查集详解：数据结构与应用
此外，还提供了一段使用Java实现并查集的示例代码。" 并查集，全称Disjoint Set Union，是一种数据结构，用于处理一系列不相交集合的合并与查询操作。在并查集中，每个元素最初都在各自独立的集合中，随着问题的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值