【每日算法】Day 2-3：并查集算法精讲——连通性问题的终极解决方案（C++实现）-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_52609538/article/details/146202365

攻克动态连通性问题！详解并查集（Union-Find）算法，从基础操作到路径压缩优化，结合大厂真题与性能分析，彻底掌握高效处理集合合并与查询的核心技巧。

一、并查集核心思想

并查集（Union-Find） 是一种树型数据结构，用于高效处理不相交集合的合并与查询问题，支持以下操作：

find(u)：查找元素所属集合（根节点）
union(u, v)：合并两个元素所属集合

应用场景：

动态连通性问题（社交网络好友关系）
图论中连通分量统计（岛屿问题）
Kruskal算法中的环检测（最小生成树）

二、算法实现与优化

基础数据结构

class UnionFind {
private:
    vector<int> parent; // 父节点数组
public:
    UnionFind(int n) : parent(n) {
        for (int i = 0; i < n; ++i) 
            parent[i] = i; // 初始化每个节点的父节点为自身
    }
};

核心操作实现

1. 查找（无优化）

int find(int x) {
    if (parent[x] != x)
        return find(parent[x]); // 递归查找根节点
    return x;
}

2. 合并（无优化）

void unite(int x, int y) {
    int rootX = find(x);
    int rootY = find(y);
    if (rootX != rootY)
        parent[rootY] = rootX; // 将Y的根节点指向X的根节点
}

优化策略

1. 路径压缩（查找优化）

int find(int x) {
    if (parent[x] != x)
        parent[x] = find(parent[x]); // 路径压缩，直接指向根节点
    return parent[x];
}

2. 按秩合并（合并优化）

class UnionFind {
private:
    vector<int> parent;
    vector<int> rank; // 树的高度秩

public:
    UnionFind(int n) : parent(n), rank(n, 1) {
        for (int i = 0; i < n; ++i) parent[i] = i;
    }

    void unite(int x, int y) {
        int rootX = find(x), rootY = find(y);
        if (rootX == rootY) return;
        
        // 按秩合并：小树合并到大树
        if (rank[rootX] > rank[rootY]) {
            parent[rootY] = rootX;
        } else {
            parent[rootX] = rootY;
            if (rank[rootX] == rank[rootY]) 
                rank[rootY]++;
        }
    }
};

三、复杂度分析

操作	无优化	路径压缩	路径压缩+按秩合并
构造函数	O(n)	O(n)	O(n)
`find`	O(h) (h为树高)	O(α(n)) ≈ O(1)	O(α(n)) ≈ O(1)
`unite`	O(h)	O(α(n))	O(α(n))

其中 α(n) 是阿克曼函数的反函数，增长极其缓慢（n ≤ 10^600 时，α(n) < 5）

四、大厂真题实战

真题1：朋友圈问题（LeetCode 547）

题目描述：
给定矩阵表示朋友关系（M[i][j] = 1 表示i和j是朋友），求朋友圈总数。

解题代码：

int findCircleNum(vector<vector<int>>& M) {
    int n = M.size();
    UnionFind uf(n);
    for (int i = 0; i < n; ++i)
        for (int j = i+1; j < n; ++j)
            if (M[i][j] == 1) uf.unite(i, j);
    
    unordered_set<int> roots;
    for (int i = 0; i < n; ++i)
        roots.insert(uf.find(i));
    return roots.size();
}

真题2：岛屿数量 II（LeetCode 305）

题目要求：
动态添加陆地位置，实时返回当前岛屿数量。

解法优化：

class Solution {
private:
    vector<int> parent;
    int count = 0;
    
    int find(int x) {
        if (parent[x] != x)
            parent[x] = find(parent[x]);
        return parent[x];
    }
    
    void unite(int x, int y) {
        int rx = find(x), ry = find(y);
        if (rx != ry) {
            parent[rx] = ry;
            count--;
        }
    }
    
public:
    vector<int> numIslands2(int m, int n, vector<vector<int>>& positions) {
        parent.resize(m*n, -1); // -1表示水域
        vector<int> res;
        vector<vector<int>> dirs = {{0,1}, {0,-1}, {1,0}, {-1,0}};
        
        for (auto& pos : positions) {
            int idx = pos[0]*n + pos[1];
            if (parent[idx] != -1) continue; // 已处理过
            
            parent[idx] = idx;
            count++;
            for (auto& d : dirs) {
                int x = pos[0]+d[0], y = pos[1]+d[1];
                int nidx = x*n + y;
                if (x>=0 && x<m && y>=0 && y<n && parent[nidx] != -1) 
                    unite(idx, nidx);
            }
            res.push_back(count);
        }
        return res;
    }
};

五、常见误区与优化技巧

路径压缩与按秩合并的冲突：同时使用时需注意秩的实际意义变为上界
初始化问题：未正确初始化父节点数组导致逻辑错误
动态扩展问题：处理动态新增节点时需灵活扩展数组
哈希替代方案：当元素非连续整数时，改用哈希表存储父节点

并行计算优化：

路径压缩的非递归实现（避免栈溢出）

int find(int x) {
    while (parent[x] != x) {
        parent[x] = parent[parent[x]]; // 路径压缩
        x = parent[x];
    }
    return x;
}

六、扩展应用场景

Kruskal算法中的环检测

// 在Kruskal算法中检测边u-v是否会形成环
if (find(u) == find(v)) 
    skip; // 会形成环
else 
    unite(u, v);

动态图的连通性维护
- 实时处理边的添加与查询操作
- 支持离线查询（批量处理）

复杂集合关系处理

带权并查集（记录节点间关系）

// 示例：处理等式方程（LeetCode 990）
vector<int> parent(26);
vector<double> weight(26, 1.0); // weight[i]表示i到父节点的权值

int find(int x) {
    if (parent[x] != x) {
        int origin = parent[x];
        parent[x] = find(parent[x]);
        weight[x] *= weight[origin];
    }
    return parent[x];
}

void unite(int x, int y, double val) {
    int rootX = find(x), rootY = find(y);
    if (rootX == rootY) return;
    parent[rootY] = rootX;
    weight[rootY] = weight[x] * val / weight[y];
}