feat: 并查集

PlutoCYF · Apr 21, 2020 · 4946d4b · 4946d4b
1 parent 893667d
commit 4946d4b
Show file tree

Hide file tree

Showing 4 changed files with 299 additions and 2 deletions.
diff --git a/README.md b/README.md
@@ -302,13 +302,14 @@ leetcode 题解，记录自己的 leetcode 解题之路。
 - [前缀树专题](./thinkings/trie.md)
 - [《日程安排》专题](https://lucifer.ren/blog/2020/02/03/leetcode-%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%E7%B3%BB%E5%88%97/)
 - [《构造二叉树》专题](https://lucifer.ren/blog/2020/02/08/%E6%9E%84%E9%80%A0%E4%BA%8C%E5%8F%89%E6%A0%91%E4%B8%93%E9%A2%98/)
-- [《贪婪策略》专题](./thinkings/greedy.md) 🆕
-- [《深度优先遍历》专题](./thinkings/DFS.md) 🆕
+- [《贪婪策略》专题](./thinkings/greedy.md)
+- [《深度优先遍历》专题](./thinkings/DFS.md)
 - [滑动窗口（思路 + 模板）](./thinkings/slide-window.md) 🆕
 - [位运算](./thinkings/bit.md) 🆕
 - [设计题](./thinkings/design.md) 🆕
 - [小岛问题](./thinkings/island.md) 🆕
 - [最大公约数](./thinkings/GCD.md) 🆕
+- [并查集](./thinkings/union-find.md) 🆕
 
 ### anki 卡片
 

diff --git a/problems/547.friend-circles.md b/problems/547.friend-circles.md
@@ -0,0 +1,86 @@
+## 题目地址（547. 朋友圈）
+
+https://leetcode-cn.com/problems/friend-circles/
+
+## 题目描述
+
+班上有  N  名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B  的朋友，B 是 C  的朋友，那么我们可以认为 A 也是 C  的朋友。所谓的朋友圈，是指所有朋友的集合。
+
+给定一个  N \* N  的矩阵  M，表示班级中学生之间的朋友关系。如果 M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。
+
+示例 1:
+
+输入:
+[[1,1,0],
+[1,1,0],
+[0,0,1]]
+输出: 2
+说明：已知学生 0 和学生 1 互为朋友，他们在一个朋友圈。
+第 2 个学生自己在一个朋友圈。所以返回 2。
+示例 2:
+
+输入:
+[[1,1,0],
+[1,1,1],
+[0,1,1]]
+输出: 1
+说明：已知学生 0 和学生 1 互为朋友，学生 1 和学生 2 互为朋友，所以学生 0 和学生 2 也是朋友，所以他们三个在一个朋友圈，返回 1。
+注意：
+
+N 在[1,200]的范围内。
+对于所有学生，有 M[i][i] = 1。
+如果有 M[i][j] = 1，则有 M[j][i] = 1。
+
+## 思路
+
+并查集有一个功能是可以轻松计算出连通分量，然而本题的朋友圈的个数，本质上就是连通分量的个数，因此用并查集可以完美解决。
+
+为了简单更加清晰，我将并查集模板代码单尽量独拿出来。
+
+## 代码
+
+`find`, `union`, `connected` 都是典型的模板方法。 懂的同学可能也发现了，我没有做路径压缩，这直接导致 find union connected 的时间复杂度最差的情况退化到 $O(N)$。
+
+当然优化也不难，我们只需要给每一个顶层元素设置一个 size 用来表示连通分量的大小，这样 union 的时候我们将小的拼接到大的上即可。 另外 find 的时候我们甚至可以路径压缩，将树高限定到常数，这样时间复杂度可以降低到 $O(1)$。
+
+```python
+class UF:
+    parent = {}
+    cnt = 0
+    def __init__(self, M):
+        n = len(M)
+        for i in range(n):
+            self.parent[i] = i
+            self.cnt += 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
+        self.parent[self.find(p)] = self.find(q)
+        self.cnt -= 1
+    def connected(self, p, q):
+        return self.find(p) == self.find(q)
+
+class Solution:
+    def findCircleNum(self, M: List[List[int]]) -> int:
+        n = len(M)
+        uf = UF(M)
+        for i in range(n):
+            for j in range(i):
+                if M[i][j] == 1:
+                    uf.union(i, j)
+        return uf.cnt
+
+```
+
+**复杂度分析**
+
+- 时间复杂度：平均 $O(logN)$，最坏的情况是 $O(N)$
+- 空间复杂度：我们使用了 parent， 因此空间复杂度为 $O(N)$
+
+欢迎关注我的公众号《脑洞前端》获取更多更新鲜的 LeetCode 题解
+
+![](https://pic.leetcode-cn.com/89ef69abbf02a2957838499a96ce3fbb26830aae52e3ab90392e328c2670cddc-file_1581478989502)
diff --git a/problems/721.accounts-merge.md b/problems/721.accounts-merge.md
@@ -0,0 +1,78 @@
+## 题目地址（721. 账户合并）
+
+https://leetcode-cn.com/problems/accounts-merge/
+
+## 题目描述
+
+给定一个列表 accounts，每个元素 accounts[i]  是一个字符串列表，其中第一个元素 accounts[i][0]  是   名称 (name)，其余元素是 emails 表示该帐户的邮箱地址。
+
+现在，我们想合并这些帐户。如果两个帐户都有一些共同的邮件地址，则两个帐户必定属于同一个人。请注意，即使两个帐户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的帐户，但其所有帐户都具有相同的名称。
+
+合并帐户后，按以下格式返回帐户：每个帐户的第一个元素是名称，其余元素是按顺序排列的邮箱地址。accounts 本身可以以任意顺序返回。
+
+例子 1:
+
+Input:
+accounts = [["John", "johnsmith@mail.com", "john00@mail.com"], ["John", "johnnybravo@mail.com"], ["John", "johnsmith@mail.com", "john_newyork@mail.com"], ["Mary", "mary@mail.com"]]
+Output: [["John", 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com'], ["John", "johnnybravo@mail.com"], ["Mary", "mary@mail.com"]]
+Explanation:
+第一个和第三个 John 是同一个人，因为他们有共同的电子邮件 "johnsmith@mail.com"。
+第二个 John 和 Mary 是不同的人，因为他们的电子邮件地址没有被其他帐户使用。
+我们可以以任何顺序返回这些列表，例如答案[['Mary'，'mary@mail.com']，['John'，'johnnybravo@mail.com']，
+['John'，'john00@mail.com'，'john_newyork@mail.com'，'johnsmith@mail.com']]仍然会被接受。
+
+注意：
+
+accounts 的长度将在[1，1000]的范围内。
+accounts[i]的长度将在[1，10]的范围内。
+accounts[i][j]的长度将在[1，30]的范围内。
+
+## 思路
+
+我们抛开 name 不管。 我们只根据 email 建立并查集即可。这样一个连通分量中的 email 就是一个人，我们在用一个 hashtable 记录 email 和 name 的映射，将其输出即可。
+
+> 如果题目不要求我们输出 name，我们自然根本不需要 hashtable 做映射
+
+## 代码
+
+`find`, `union`, `connected` 都是典型的模板方法。 懂的同学可能也发现了，我没有做路径压缩，这直接导致 find union connected 的时间复杂度最差的情况退化到 $O(N)$。
+
+当然优化也不难，我们只需要给每一个顶层元素设置一个 size 用来表示连通分量的大小，这样 union 的时候我们将小的拼接到大的上即可。 另外 find 的时候我们甚至可以路径压缩，将树高限定到常数，这样时间复杂度可以降低到 $O(1)$。
+
+```python
+class UF:
+    def __init__(self):
+        self.parent = {}
+
+    def find(self, x):
+        self.parent.setdefault(x, x)
+        while x != self.parent[x]:
+            x = self.parent[x]
+        return x
+    def union(self, p, q):
+        self.parent[self.find(p)] = self.find(q)
+
+
+class Solution:
+    def accountsMerge(self, accounts: List[List[str]]) -> List[List[str]]:
+        uf = UF()
+        email_to_name = {}
+        res = collections.defaultdict(list)
+        for account in accounts:
+            for i in range(1, len(account)):
+                email_to_name[account[i]] = account[0]
+                if i < len(account) - 1:uf.union(account[i], account[i + 1])
+        for email in email_to_name:
+            res[uf.find(email)].append(email)
+
+        return [[email_to_name[value[0]]] + sorted(value) for value in res.values()]
+```
+
+**复杂度分析**
+
+- 时间复杂度：平均 $O(logN)$，最坏的情况是 $O(N)$
+- 空间复杂度：我们使用了 parent， 因此空间复杂度为 $O(N)$
+
+欢迎关注我的公众号《脑洞前端》获取更多更新鲜的 LeetCode 题解
+
+![](https://pic.leetcode-cn.com/89ef69abbf02a2957838499a96ce3fbb26830aae52e3ab90392e328c2670cddc-file_1581478989502)
diff --git a/thinkings/union-find.md b/thinkings/union-find.md
@@ -0,0 +1,132 @@
+# 并查集
+
+关于并查集的题目不少，官方给的数据是 30 道（截止 2020-02-20），但是有一些题目虽然官方没有贴`并查集`标签，但是使用并查集来说确非常简单。这类题目如果掌握模板，那么刷这种题会非常快，并且犯错的概率会大大降低，这就是模板的好处。
+
+我这里总结了几道并查集的题目：
+
+- [547. 朋友圈](../problems/547.friend-circles.md)
+- [721. 账户合并](https://leetcode-cn.com/problems/accounts-merge/solution/mo-ban-ti-bing-cha-ji-python3-by-fe-lucifer-3/)
+- [990. 等式方程的可满足性](https://github.com/azl397985856/leetcode/issues/304)
+
+看完这里的内容，建议拿上面的题目练下手，检测一下学习成果。
+
+## 概述
+
+并查集是一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。有一个联合-查找算法（Union-find Algorithm）定义了两个用于此数据结构的操作：
+
+- Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。
+- Union：将两个子集合并成同一个集合。
+
+由于支持这两种操作，一个不相交集也常被称为联合-查找数据结构（Union-find Data Structure）或合并-查找集合（Merge-find Set）。为了更加精确的定义这些方法，需要定义如何表示集合。一种常用的策略是为每个集合选定一个固定的元素，称为代表，以表示整个集合。接着，Find(x) 返回 x 所属集合的代表，而 Union 使用两个集合的代表作为参数。
+
+## 形象解释
+
+比如有两个司令。 司令下有若干军长，军长下有若干师长。。。
+
+我们如何判断某两个师长是否属于同一个司令呢（连通性）？
+
+![](https://tva1.sinaimg.cn/large/007S8ZIlly1ge1ap6p77yj30gs0bz3zn.jpg)
+
+很简单，我们顺着师长，往上找，找到司令。 如果两个师长找到的是同一个司令，那么就属于同一个司令。我们用 parent[x] = y 表示 x 的 parent 是 y，通过不断沿着搜索 parent 搜索找到 root，然后比较 root 是否相同即可得出结论。
+
+以上过程涉及了两个基本操作`find`和`connnected`。 并查集除了这两个基本操作，还有一个是`union`。即将两个集合合并为同一个。
+
+如图有两个司令：
+
+![](https://tva1.sinaimg.cn/large/007S8ZIlly1ge1auw6z8oj30wp0eljth.jpg)
+
+我们将其合并为一个联通域，最简单的方式就是直接将其中一个司令指向另外一个即可：
+
+![](https://tva1.sinaimg.cn/large/007S8ZIlly1ge1awrmaclj30ym0cogo4.jpg)
+
+以上就是三个核心 API `find`，`connnected` 和 `union`， 的形象化解释，下面我们来看下代码实现。
+
+## 核心 API
+
+### find
+
+```python
+def find(self, x):
+    while x != self.parent[x]:
+        x = self.parent[x]
+    return x
+```
+
+### connected
+
+```python
+def connected(self, p, q):
+    return self.find(p) == self.find(q)
+```
+
+### union
+
+```python
+def union(self, p, q):
+    if self.connected(p, q): return
+    self.parent[self.find(p)] = self.find(q)
+```
+
+## 完整代码模板
+
+```python
+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)
+```
+
+## 带路径压缩的代码模板
+
+```python
+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)
+```
+
+上面是递归的方式进行路径压缩，写起来比较简单。但是有栈溢出的风险。 接下来我们看下迭代的写法：
+
+```python
+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)
+```