并查集

并查集模板

class UnionFind:
    def __init__(self):
        """
        记录每个节点的父节点
        """
        self.father = {}
    
    def find(self,x):
        """
        查找根节点
        路径压缩
        """
        root = x

        while self.father[root] != None:
            root = self.father[root]

        # 路径压缩
        while x != root:
            original_father = self.father[x]
            self.father[x] = root
            x = original_father
         
        return root
    
    def merge(self,x,y,val):
        """
        合并两个节点
        """
        root_x,root_y = self.find(x),self.find(y)
        
        if root_x != root_y:
            self.father[root_x] = root_y

    def is_connected(self,x,y):
        """
        判断两节点是否相连
        """
        return self.find(x) == self.find(y)
    
    def add(self,x):
        """
        添加新节点
        """
        if x not in self.father:
            self.father[x] = None

基本概念
并查集是一种数据结构
并查集这三个字，一个字代表一个意思。
并（Union），代表合并
查（Find），代表查找
集（Set），代表这是一个以字典为基础的数据结构，它的基本功能是合并集合中的元素，查找集合中的元素
并查集的典型应用是有关连通分量的问题
并查集解决单个问题（添加，合并，查找）的时间复杂度都是O(1)O(1)
因此，并查集可以应用到在线算法中
并查集的实现
数据结构
并查集跟树有些类似，只不过她跟树是相反的。在树这个数据结构里面，每个节点会记录它的子节点。在并查集里，每个节点会记录它的父节点。

class UnionFind:

    def __init__(self):
        """
        记录每个节点的父节点
        """
        self.father = {}

可以看到，如果节点是相互连通的（从一个节点可以到达另一个节点），那么他们在同一棵树里，或者说在同一个集合里，或者说他们的祖先是相同的。

初始化
当把一个新节点添加到并查集中，它的父节点应该为空

def add(self,x):
    """
    添加新节点
    """
    if x not in self.father:
        self.father[x] = None

合并两个节点
如果发现两个节点是连通的，那么就要把他们合并，也就是他们的祖先是相同的。这里究竟把谁当做父节点一般是没有区别的。

def merge(self,x,y,val):
    """
    合并两个节点
    """
    root_x,root_y = self.find(x),self.find(y)
    
    if root_x != root_y:
        self.father[root_x] = root_y

两节点是否连通
我们判断两个节点是否处于同一个连通分量的时候，就需要判断它们的祖先是否相同

   def is_connected(self,x,y):
        """
        判断两节点是否相连
        """
        return self.find(x) == self.find(y)

查找祖先
查找祖先的方法是：如果节点的父节点不为空，那就不断迭代。

def find(self,x):
“”"
查找根节点
“”"
root = x

while self.father[root] != None:
    root = self.father[root]

return root

这里有一个优化的点：如果我们树很深，比如说退化成链表，那么每次查询的效率都会非常低。所以我们要做一下路径压缩。也就是把树的深度固定为二。

这么做可行的原因是，并查集只是记录了节点之间的连通关系，而节点相互连通只需要有一个相同的祖先就可以了。

路径压缩可以用递归，也可以迭代。这里用迭代的方法。

def find(self,x):
“”"
查找根节点
路径压缩
“”"
root = x

while self.father[root] != None:
    root = self.father[root]

# 路径压缩
while x != root:
    original_father = self.father[x]
    self.father[x] = root
    x = original_father
 
return root

路径压缩的时间复杂度为O(\log^*n)O(log
∗
n)

\log^*nlog
∗
n 表示 n 取多少次\log_2nlog
2
​
n并向下取整以后 变成 1

可以认为O(\log^*n) = O(1)O(log
∗
n)=O(1),因为\log^*2{65536} = 5log
∗
2
65536
=5，而2^{65536}2
65536
是一个天文数字。这个时间复杂度当成结论记下就可以。

class UnionFind:
    def __init__(self):
        """
        记录每个节点的父节点
        """
        self.father = {}
    
    def find(self,x):
        """
        查找根节点
        路径压缩
        """
        root = x

        while self.father[root] != None:
            root = self.father[root]

        # 路径压缩
        while x != root:
            original_father = self.father[x]
            self.father[x] = root
            x = original_father
         
        return root
    
    def merge(self,x,y,val):
        """
        合并两个节点
        """
        root_x,root_y = self.find(x),self.find(y)
        
        if root_x != root_y:
            self.father[root_x] = root_y

    def is_connected(self,x,y):
        """
        判断两节点是否相连
        """
        return self.find(x) == self.find(y)
    
    def add(self,x):
        """
        添加新节点
        """
        if x not in self.father:
            self.father[x] = None

以上就是并查集的基本模板，根据不同的题目要求进行对应的添加即可。

考察连通分量的数目，所以我们要在模板中额外添加一个变量去跟踪集合的数量（有多少棵树）。
初始化的时候把集合数量加一
合并的时候让集合数量减一

class UnionFind:
    def __init__(self):
        self.father = {}
        # 额外记录集合的数量
        self.num_of_sets = 0
    
    def find(self,x):
        root = x
        
        while self.father[root] != None:
            root = self.father[root]
        
        while x != root:
            original_father = self.father[x]
            self.father[x] = root
            x = original_father
        
        return root
    
    def merge(self,x,y):
        root_x,root_y = self.find(x),self.find(y)
        
        if root_x != root_y:
            self.father[root_x] = root_y
            # 集合的数量-1
            self.num_of_sets -= 1
    
    def add(self,x):
        if x not in self.father:
            self.father[x] = None
            # 集合的数量+1
            self.num_of_sets += 1

class Solution:
    def findCircleNum(self, M: List[List[int]]) -> int:
        uf = UnionFind()
        for i in range(len(M)):
            uf.add(i)
            for j in range(i):
                if M[i][j]:
                    uf.add(j)
                    uf.merge(i,j)
        
        return uf.num_of_sets

相关题目

模板题：
以图判树
无向图中连通分量的数目

在线算法：
岛屿数量 II

其他：
除法求值
账户合并
打砖块
矩阵转换后的秩