以下是关于并查集（Disjoint Set Union, DSU） 的详细中文解析：

一、什么是并查集？

一种用于高效管理 元素分组 和 动态连通性 的数据结构，支持两种核心操作：

1. 合并（Union）：将两个不相交集合合并为一个。
2. 查找（Find）：确定元素属于哪个集合（通常返回集合的代表元素）。

二、核心思想

1. 森林表示法
   用多棵树表示集合，每棵树的根节点是该集合的代表元素。
   

2. 路径压缩（Find优化）
   查找时扁平化路径，减少后续查询时间。

   def find(x):
      if parent[x] != x:
          parent[x] = find(parent[x])  # 递归压缩路径
      return parent[x]

3. 按秩合并（Union优化）
   合并时将小树挂到大树根下，避免树过高。

   def union(x, y):
      rx, ry = find(x), find(y)
      if rx == ry: return
      if rank[rx] < rank[ry]:   # 按秩合并
          parent[rx] = ry
      elif rank[rx] > rank[ry]:
          parent[ry] = rx
      else:
          parent[ry] = rx
          rank[rx] += 1

三、代码模板（Python）

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n

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

    def union(self, x, y):
        rx, ry = self.find(x), self.find(y)
        if rx == ry: return

        if self.rank[rx] < self.rank[ry]:
            self.parent[rx] = ry
        elif self.rank[rx] > self.rank[ry]:
            self.parent[ry] = rx
        else:
            self.parent[ry] = rx
            self.rank[rx] += 1

四、时间复杂度

$\alpha(n)$ 是反阿克曼函数，通常小于 5（效率接近 $O(1)$）

五、经典应用场景

1. 连通性问题

   • 判断图中两点是否连通（如：LeetCode 547 省份数量）

     # 遍历所有边，合并相连节点
     for u, v in edges:
     uf.union(u, v)

2. 最小生成树（Kruskal算法）

   • 按边权重排序后合并，避免成环。

3. 动态图的连通性
   支持在线添加边并实时查询连通性。

4. 分组问题

   • 社交网络好友分组、岛屿数量等。

六、例题实战

题目：LeetCode 200. 岛屿数量
思路：

• 遍历网格，将相邻陆地（'1'）合并为一个集合
• 最终统计根节点数量即为岛屿数

def numIslands(grid: List[List[str]]) -> int:
    m, n = len(grid), len(grid[0])
    uf = UnionFind(m * n)

    for i in range(m):
        for j in range(n):
            if grid[i][j] == '0': continue
            idx = i * n + j
            # 检查右方和下方相邻陆地
            for dx, dy in [(1,0), (0,1)]:
                ni, nj = i+dx, j+dy
                if ni < m and nj < n and grid[ni][nj]=='1':
                    nidx = ni * n + nj
                    uf.union(idx, nidx)

    # 统计根节点数量（代表元素）
    roots = set()
    for i in range(m):
        for j in range(n):
            if grid[i][j]=='1':
                roots.add(uf.find(i * n + j))
    return len(roots)

七、常见问题

1. 如何处理初始化？
   每个元素初始化为独立集合，父节点指向自身。

2. 为什么需要路径压缩和按秩合并？
   避免树退化成链，保证操作高效性。

3. 能否用哈希表替代数组？
   可以，但数组更高效（元素编号连续时优先使用）。

总结：并查集是解决动态连通性问题的利器，核心在于路径压缩与按秩合并的优化组合，将时间复杂度降至近 $O(1)$ 。掌握其思想后，可灵活应用于图论、分组等问题。