- [《贪婪策略》专题](./thinkings/greedy.md)

- [《深度优先遍历》专题](./thinkings/DFS.md)

- [并查集](./thinkings/union-find.md) 🆕

班上有  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)$。

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 题解

给定一个列表 accounts，每个元素 accounts[i]  是一个字符串列表，其中第一个元素 accounts[i][0]  是   名称 (name)，其余元素是 emails 表示该帐户的邮箱地址。

现在，我们想合并这些帐户。如果两个帐户都有一些共同的邮件地址，则两个帐户必定属于同一个人。请注意，即使两个帐户具有相同的名称，它们也可能属于不同的人，因为人们可能具有相同的名称。一个人最初可以拥有任意数量的帐户，但其所有帐户都具有相同的名称。

合并帐户后，按以下格式返回帐户：每个帐户的第一个元素是名称，其余元素是按顺序排列的邮箱地址。accounts 本身可以以任意顺序返回。

例子 1:

Input:

accounts = [["John", "[email protected]", "[email protected]"], ["John", "[email protected]"], ["John", "[email protected]", "[email protected]"], ["Mary", "[email protected]"]]

Output: [["John", '[email protected]', '[email protected]', '[email protected]'], ["John", "[email protected]"], ["Mary", "[email protected]"]]

Explanation:

第一个和第三个 John 是同一个人，因为他们有共同的电子邮件 "[email protected]"。

第二个 John 和 Mary 是不同的人，因为他们的电子邮件地址没有被其他帐户使用。

我们可以以任何顺序返回这些列表，例如答案[['Mary'，'[email protected]']，['John'，'[email protected]']，

['John'，'[email protected]'，'[email protected]'，'[email protected]']]仍然会被接受。

注意：

accounts 的长度将在[1，1000]的范围内。

accounts[i]的长度将在[1，10]的范围内。

accounts[i][j]的长度将在[1，30]的范围内。

我们抛开 name 不管。 我们只根据 email 建立并查集即可。这样一个连通分量中的 email 就是一个人，我们在用一个 hashtable 记录 email 和 name 的映射，将其输出即可。

`find`, `union`, `connected` 都是典型的模板方法。 懂的同学可能也发现了，我没有做路径压缩，这直接导致 find union connected 的时间复杂度最差的情况退化到 $O(N)$。

当然优化也不难，我们只需要给每一个顶层元素设置一个 size 用来表示连通分量的大小，这样 union 的时候我们将小的拼接到大的上即可。 另外 find 的时候我们甚至可以路径压缩，将树高限定到常数，这样时间复杂度可以降低到 $O(1)$。

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 题解

关于并查集的题目不少，官方给的数据是 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 使用两个集合的代表作为参数。

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

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

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

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

如图有两个司令：

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

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

def find(self, x):

while x != self.parent[x]:

x = self.parent[x]

return x

def connected(self, p, q):

return self.find(p) == self.find(q)

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)