并查集专题

最新推荐文章于 2020-05-11 21:21:30 发布

fe_lucifer

最新推荐文章于 2020-05-11 21:21:30 发布

阅读量232

点赞数

本文链接：https://blog.csdn.net/azl397985856/article/details/105672054

版权

关于并查集的题目不少，官方给的数据是 30 道（截止 2020-02-20），但是有一些题目虽然官方没有贴并查集标签，但是使用并查集来说确非常简单。这类题目如果掌握模板，那么刷这种题会非常快，并且犯错的概率会大大降低，这就是模板的好处。

我这里总结了几道并查集的题目：

547. 朋友圈
721. 账户合并
990. 等式方程的可满足性

看完这里的内容，建议拿上面的题目练下手，检测一下学习成果。

概述

并查集是一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。有一个联合-查找算法（Union-find Algorithm）定义了两个用于此数据结构的操作：

Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。
Union：将两个子集合并成同一个集合。

由于支持这两种操作，一个不相交集也常被称为联合-查找数据结构（Union-find Data Structure）或合并-查找集合（Merge-find Set）。为了更加精确的定义这些方法，需要定义如何表示集合。一种常用的策略是为每个集合选定一个固定的元素，称为代表，以表示整个集合。接着，Find(x) 返回 x 所属集合的代表，而 Union 使用两个集合的代表作为参数。

形象解释

比如有两个司令。司令下有若干军长，军长下有若干师长。。。

我们如何判断某两个师长是否属于同一个司令呢（连通性）？

很简单，我们顺着师长，往上找，找到司令。如果两个师长找到的是同一个司令，那么就属于同一个司令。我们用 parent[x] = y 表示 x 的 parent 是 y，通过不断沿着搜索 parent 搜索找到 root，然后比较 root 是否相同即可得出结论。

以上过程涉及了两个基本操作find和connnected。并查集除了这两个基本操作，还有一个是union。即将两个集合合并为同一个。

如图有两个司令：

我们将其合并为一个联通域，最简单的方式就是直接将其中一个司令指向另外一个即可：

以上就是三个核心 API find，connnected 和 union，的形象化解释，下面我们来看下代码实现。

核心 API

find

def find(self, x):
    while x != self.parent[x]:
        x = self.parent[x]
    return x

connected

def connected(self, p, q):
    return self.find(p) == self.find(q)

union

def union(self, p, q):
    if self.connected(p, q): return
    self.parent[self.find(p)] = self.find(q)

完整代码模板

class UF:
    parent = {}
    def __init__(self, equations):
        # 做一些初始化操作

    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
        self.parent[self.find(p)] = self.find(q)
    def connected(self, p, q):
        return self.find(p) == self.find(q)

带路径压缩的代码模板

class UF:
    parent = {}
    def __init__(self, equations):
        # 做一些初始化操作
    def find(self, x):
        if x != self.parent[x]:
            parent[x] = find(parent[x])
        return parent[x]
    def union(self, p, q):
        if self.connected(p, q): return
        self.parent[self.find(p)] = self.find(q)
    def connected(self, p, q):
        return self.find(p) == self.find(q)

上面是递归的方式进行路径压缩，写起来比较简单。但是有栈溢出的风险。接下来我们看下迭代的写法：

class UF:
    parent = {}
    def __init__(self, equations):
        # 做一些初始化操作

    def find(self, x):
        # 根节点
        r = x
        while r != parent[r]:
            r = parent[r]
        k = x
        while k != r:
            # 暂存parent[k]的父节点
            j = parent[k]
            parent[k] = r
            k = j
        return r
    def union(self, p, q):
        if self.connected(p, q): return
        self.parent[self.find(p)] = self.find(q)
    def connected(self, p, q):
        return self.find(p) == self.find(q)

1、每日一荐 2020-03 汇总

2、『不要再问我头像如何变灰了，试试这几种滤镜吧！』

3、LeetCode专题 - 小岛题

4、一文带你AC四道题【位运算】

5、或许是一本可以彻底改变你刷 LeetCode 效率的题解书

6、外部排序：如何用 2GB内存给 20 亿个整数排序？