并查集模板

最新推荐文章于 2022-10-10 14:42:24 发布

青竹aaa

最新推荐文章于 2022-10-10 14:42:24 发布

阅读量134

点赞数

分类专栏：算法刷题文章标签：数据结构算法 python

本文链接：https://blog.csdn.net/qq_36575363/article/details/112686812

版权

算法刷题专栏收录该内容

29 篇文章 0 订阅

订阅专栏

考研人信息库

此公众号会发表计算机考研（初复试信息）、夏令营等资料，方便考研人对信息的获取，节约自身查找资料的时间，回复408，可获得数据结构、操作系统、计算机网络、计算机组成原理全科资料

不带权并查集

带路径压缩的代码模板

class UF:
    def __init__(self, M):
        self.parent = {}
        self.size = {}#维护一个秩，它表示该结点高度的上界
        self.cnt = 0#记录形成集合的个数
        # 初始化 parent，size 和 cnt
        for i in range(M):
            self.parent[i] = i
            self.cnt += 1
            self.size[i] = 1
    def find(self, x):
        while x != self.parent[x]:
            x = self.parent[x]
        return x
    def union(self, p, q):
        if self.connected(p, q): return
        # 小的树挂到大的树上， 使树尽量平衡
        leader_p = self.find(p)
        leader_q = self.find(q)
        if self.size[leader_p] < self.size[leader_q]:
            self.parent[leader_p] = leader_q
            #self.size[leader_p] += self.size[leader_q]
            self.size[leader_p] =1 + self.size[leader_p]
        else:
            self.parent[leader_q] = leader_p
            #self.size[leader_q] += self.size[leader_p]
            self.size[leader_p] =1 + self.size[leader_p]
        self.cnt -= 1
    #判断结点p,q是否在同一个集合内
    def connected(self, p, q):
        return self.find(p) == self.find(q)
---------------------------------------------------------------
class UF:
    def __init__(self,M):
        self.parent={}
        self.size={}
        self.cnt=0
        for i in range(M):
            self.parent[i]=i
            self.size[i]=1
            self.cnt+=1
    def find(self,x):
        while x!=self.parent[x]:
            x=self.parent[x]
        return x
    def union(self,x,y):
        if self.find(x)==self.find(y):
            return
        parent_x=self.find(x)
        parent_y=self.find(y)
        if self.size[parent_x]<self.size[parent_y]:
            self.parent[parent_x]=parent_y
        else:
            self.parent[parent_y]=parent_x
            if self.size[parent_x]==self.size[parent_y]:
                self.size[parent_x]=1+self.size[parent_x]
        self.cnt-=1

带权并查集

实际上并查集就是图结构，我们使用了哈希表来模拟这种图的关系。而上面讲到的其实都是有向无权图，因此仅仅使用 parent 表示节点关系就可以了。而如果使用的是有向带权图呢？实际上除了维护 parent 这样的节点指向关系，我们还需要维护节点的权重，一个简单的想法是使用另外一个哈希表 weight 存储节点的权重关系。比如 weight[a] = 1 表示 a 到其父节点的权重是 1。

如果是带权的并查集，其查询过程的路径压缩以及合并过程会略有不同，因为我们不仅关心节点指向的变更，也关心权重如何更新。比如：

a    b
^    ^
|    |
|    |
x    y

如上表示的是 x 的父节点是 a，y 的父节点是 b，现在我需要将 x 和 y 进行合并。

a    b
^    ^
|    |
|    |
x -> y

假设 x 到 a 的权重是 w(xa)，y 到 b 的权重为 w(yb)，x 到 y 的权重是 w(xy)。合并之后会变成如图的样子：

a -> b
^    ^
|    |
|    |
x    y

那么 a 到 b 的权重应该被更新为什么呢？我们知道 w(xa) + w(ab) = w(xy) + w(yb)，也就是说 a 到 b 的权重 w(ab) = w(xy) + w(yb) - w(xa)。

当然上面关系式是加法，减法，取模还是乘法，除法等完全由题目决定，我这里只是举了一个例子。不管怎么样，这种运算一定需要满足可传导性。

带路径压缩的代码模板

这里以加法型带权并查集为例，讲述一下代码应该如何书写。

class UF:
    def __init__(self, M):
        # 初始化 parent，weight
        self.parent = {}
        self.weight = {}
        for i in range(M):
            self.parent[i] = i
            self.weight[i] = 0

   def find(self, x):
        if self.parent[x] != x:
            ancestor, w = self.find(self.parent[x])
            self.parent[x] = ancestor
            self.weight[x] += w
        return self.parent[x], self.weight[x]
    def union(self, p, q, dist):
        if self.connected(p, q): return
        leader_p, w_p = self.find(p)
        leader_q, w_q = self.find(q)
        self.parent[leader_p] = leader_q
        self.weight[leader_p] = dist + w_q - w_p
    def connected(self, p, q):
        return self.find(p)[0] == self.find(q)[0]

例题

n 块石头放置在二维平面中的一些整数坐标点上。每个坐标点上最多只能有一块石头。

如果一块石头的同行或者同列上有其他石头存在，那么就可以移除这块石头。

给你一个长度为 n 的数组 stones ，其中 stones[i] = [xi, yi] 表示第 i 块石头的位置，返回可以移除的石子的最大数量。

示例 1：

输入：stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]
输出：5
解释：一种移除 5 块石头的方法如下所示：
1. 移除石头 [2,2] ，因为它和 [2,1] 同行。
2. 移除石头 [2,1] ，因为它和 [0,1] 同列。
3. 移除石头 [1,2] ，因为它和 [1,0] 同行。
4. 移除石头 [1,0] ，因为它和 [0,0] 同列。
5. 移除石头 [0,1] ，因为它和 [0,0] 同行。
石头 [0,0] 不能移除，因为它没有与另一块石头同行/列。

示例 2：

输入：stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]
输出：3
解释：一种移除 3 块石头的方法如下所示：
1. 移除石头 [2,2] ，因为它和 [2,0] 同行。
2. 移除石头 [2,0] ，因为它和 [0,0] 同列。
3. 移除石头 [0,2] ，因为它和 [0,0] 同行。
石头 [0,0] 和 [1,1] 不能移除，因为它们没有与另一块石头同行/列。

示例 3：

输入：stones = [[0,0]]
输出：0
解释：[0,0] 是平面上唯一一块石头，所以不可以移除它。

提示：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/most-stones-removed-with-same-row-or-column

解法

class UF:
    def __init__(self, M):
        self.parent = {}
        self.size = {}#维护一个秩，它表示该结点高度的上界
        self.cnt = 0#记录形成集合的个数
        # 初始化 parent，size 和 cnt
        for i in range(M):
            self.parent[i] = i
            self.cnt += 1
            self.size[i] = 1
    def find(self, x):
        while x != self.parent[x]:
            x = self.parent[x]
        return x
    def union(self, p, q):
        if self.connected(p, q): return
        # 小的树挂到大的树上， 使树尽量平衡
        leader_p = self.find(p)
        leader_q = self.find(q)
        if self.size[leader_p] < self.size[leader_q]:
            self.parent[leader_p] = leader_q
            #self.size[leader_p] += self.size[leader_q]
            self.size[leader_p] =1 + self.size[leader_p]
        else:
            self.parent[leader_q] = leader_p
            #self.size[leader_q] += self.size[leader_p]
            self.size[leader_p] =1 + self.size[leader_p]
        self.cnt -= 1
    #判断结点p,q是否在同一个集合内
    def connected(self, p, q):
        return self.find(p) == self.find(q)
class Solution:
    def removeStones(self, stones: List[List[int]]) -> int:
        n = len(stones)
        uf = UF(n)
        for i in range(n):
            for j in range(i + 1, n):
                if stones[i][0] == stones[j][0] or stones[i][1] == stones[j][1]: uf.union(i, j)
        return n - uf.cnt

青竹aaa

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
并查集模板

此公众号会发表计算机考研（初复试信息）、夏令营等资料，方便考研人对信息的获取，节约自身查找资料的时间，回复408，可获得数据结构、操作系统、计算机网络、计算机组成原理全科资料目录不带权并查集带路径压缩的代码模板带权并查集带路径压缩的代码模板例题解法不带权并查集带路径压缩的代码模板class UF: def __init__(self, M): self.parent = {} self.si...
复制链接

扫一扫