并查集教程：入门级详解与实践指南

并查集（Disjoint Set Union，简称DSU）是一种高效处理集合合并与查询操作的数据结构。它在图论问题、算法优化与集合划分等场景中具有广泛的应用。文中详细介绍了并查集的基本概念、操作方法以及在桥检测和最小生成树算法等领域的实现与优化策略，旨在帮助读者掌握并查集的实战应用与性能优化。

引入并查集的概念

并查集是一种用于处理集合合并与查询的数据结构，适用于解决涉及图论和集合的问题，如计算图中的连通分量、检测桥、实现最小生成树算法（如Kruskal算法）等。

并查集的用途与应用场景

并查集广泛应用于：

• 图论问题：解决连通性问题，例如计算图中的连通分量、检测图中的桥边与检测网络中的连通分量。
• 算法优化：在实现最小生成树算法、最短路径算法（如Dijkstra算法和Floyd算法）中作为辅助数据结构。
• 集合划分问题：快速合并和查询多个集合的分组情况。

并查集的基本操作

并查集支持以下核心操作：

1. 初始化集合：为每个元素创建独立的集合。
2. 查找集合：确定元素所属集合的代表元素（根节点）。
3. 合并集合：将两个集合合并为一个集合。

实现并查集

顺序表实现

顺序表形式的并查集使用数组存储每个元素所属集合的根节点。数组元素指示其所在集合的根。

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(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):
        rootX = self.find(x)
        rootY = self.find(y)
        if rootX != rootY:
            self.parent[rootX] = rootY

指针实现（路径压缩与按秩合并优化）

优化：路径压缩

通过路径压缩优化，每次查找元素时，直接将元素与根节点直接连接，从而减少查找路径长度，提高查询效率。

class UnionFind:
    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):
        rootX = self.find(x)
        rootY = self.find(y)
        if rootX != rootY:
            if self.rank[rootX] < self.rank[rootY]:
                self.parent[rootX] = rootY
            elif self.rank[rootX] > self.rank[rootY]:
                self.parent[rootY] = rootX
            else:
                self.parent[rootY] = rootX
                self.rank[rootX] += 1

并查集的应用示例

案例分析：桥检测

桥检测算法利用并查集检测图中不能跨越的边，即桥边。这些边的删除会导致图的连通性发生变化。

def bridges(graph):
    n = len(graph)
    visited = [False] * n
    low = [float('inf')] * n
    disc = [float('inf')] * n
    parent = [-1] * n
    time = 0
    bridges = []

    def dfs(node, parent_node):
        nonlocal time
        visited[node] = True
        disc[node] = low[node] = time
        time += 1
        children = 0
        for neighbor in graph[node]:
            if not visited[neighbor]:
                parent[neighbor] = node
                dfs(neighbor, node)
                low[node] = min(low[node], low[neighbor])
                if low[neighbor] > disc[node]:
                    bridges.append((node, neighbor))
            elif neighbor != parent_node:
                low[node] = min(low[node], disc[neighbor])
        return children

    for i in range(n):
        if not visited[i]:
            if dfs(i, -1) > 0:
                bridges.append((i, -1))

    return bridges

最小生成树（Kruskal算法）

并查集在Kruskal算法中用于检测加入边是否会导致形成环，从而构建最小生成树。

def kruskal(graph):
    n = len(graph)
    edges = [(w, u, v) for u, v, w in graph]
    edges.sort()
    uf = UnionFind(n)
    mst = []

    for w, u, v in edges:
        if uf.find(u) != uf.find(v):
            uf.union(u, v)
            mst.append((u, v, w))

    return mst

并查集的优化

路径压缩的原理与实现

路径压缩通过在查找路径上直接将元素连接到根节点，减少查找路径长度，提升查询效率。

按秩合并的原理与实现

按秩合并策略通过维护集合树的高度（秩），优先合并高度较低的集合，以减少新集合的高度，提高查询效率。

实战练习与案例分析

编写并查集模板代码

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(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):
        self.parent[self.find(x)] = self.find(y)

应用并查集解决实际问题

• 图论练习：实现并查集的桥检测和最小生成树算法，并通过实际数据进行验证和测试。
• 性能优化：在不同图结构和规模下，对比标准实现和优化后的并查集在执行效率上的差异，评估哪些优化更为有效。

结语

并查集是解决集合问题的强大工具，通过适当的优化（如路径压缩和按秩合并），其性能可以得到显著提升。掌握并查集的使用方法，不仅能够解决一系列经典图论问题，还能为算法设计提供有力支持。在实际应用中灵活运用并查集，能够提升问题解决的效率和质量。