并查集算法笔记

并查集算法笔记

定义

并查集是一种用来管理元素分组情况的数据结构，并查集可以高效的进行如下操作

• 查询元素a和元素b是否属于同一组
• 合并元素a和元素b所在的组

并查集结构

使用树状结构来实现

并查集支持的操作

• 合并一个组的根指向另一个组的根连边，这样两棵树变成了一棵树，合并了两个组

• 查询

  如果两个节点的根相同，就可以知道它们属于同一组。

  

并查集实现中的注意

在树形数据结构中，如果发生了退化的情况，复杂度就会变得很高。在并查集中，可以按照如下方法避免退化：

• 对于每棵树，记录这棵树的高度，合并时如果两棵树的高度不同，从高度小的向高度大的连边

  

• 路劲压缩

  在查询过程中向上经过的所有的节点，都改为直接连到根上

并查集模板

class UnionFind{
public:
    vector<int>father;
    UnionFind(int num){//num表示元素的个数
        for(int i = 0; i < num; i++){
            father.push_back(i);//箭头指向自己
        }
    }
    int Find(int n){//查找
        //递归
        if(father[n] == n)//
            return n;
        father[n] = Find(father[n]);//路径压缩版本
        return father[n];
    }
    void Union(int a, int b){//合并
        int fa = Find(a);
        int fb = Find(b);
        father[fb] = fa;
    }
};

并查集复杂度平均下来每次查询和合并的复杂度都是常数的（阿克曼函数）。

例题

LeetCode 547. Friend Circles

题目描述

班上有N名学生。他们中的一些人是朋友，而有些则不是。他们的友谊本质上是传递性的。例如，如果A是B的直接朋友，而B是C的直接朋友，那么A是C的间接朋友。我们定义的朋友圈是一群直接或间接的朋友。

给定N * N矩阵M表示班级中学生之间的朋友关系。如果M [i] [j] = 1，那么第i和第j个学生是彼此的直接朋友，否则不是。而且你必须在所有学生中输出朋友圈的总数。

样例

输入：
[[1,1,0],
[1,1,0],
[0,0,1]]
输出：2
学生0和学生1是直接朋友，所以他们俩是一个朋友圈，学生2跟自己是朋友，所以有两个朋友圈

代码

class UnionFind{
public:
    vector<int>father;
    UnionFind(int num){//num表示元素的个数
        for(int i = 0; i < num; i++){
            father.push_back(i);//箭头指向自己
        }
    }
    int Find(int n){
        //递归
        if(father[n] == n)
            return n;
        father[n] = Find(father[n]);//路径压缩版本
        return father[n];
    }
    void Union(int a, int b){
        int fa = Find(a);
        int fb = Find(b);
        father[fb] = fa;
    }
};
class Solution {
public:  
    int findCircleNum(vector<vector<int>>& M) {
        int N = M.size();
        UnionFind UF(N);
        for(int i = 0; i < N; i++){
            for(int j = 0; j < N; j++){
                if(M[i][j]){
                    UF.Union(i, j);//两个人是朋友则合并朋友圈
                }
            }
        }
        int res = 0;
        for(int i = 0; i < N; i++){
            if(UF.Find(i) == i)//计算朋友圈的个数
                res++;
        }
        return res;
    }
};

LeetCode 200. Number of Islands

题目描述

给定包含‘1’（陆地）和‘0’（水）的2维网格图，计算岛屿数量。岛被水包围，通过水平或垂直连接相邻的土地而形成。你可以假设网格的所有四个边都被水包围。

样例

输入：
11110
11010
11000
00000
输出: 1
解释：可以看到岛屿可以全部连成一块，所以最后是1个岛屿

输入：
11000
11000
00100
00011
输出: 3
解释：可以看到左上角有一片岛屿，中间有一片岛屿，右下角有一片岛屿，所以最后是3个岛屿

代码

class UnionFind{
public:
    vector<int>father;
    UnionFind(int num){//num表示元素的个数
        for(int i = 0; i < num; i++){
            father.push_back(i);//箭头指向自己
        }
    }
    int Find(int n){
        //递归
        if(father[n] == n)
            return n;
        father[n] = Find(father[n]);//路径压缩版本
        return father[n];
    }
    void Union(int a, int b){
        int fa = Find(a);
        int fb = Find(b);
        father[fb] = fa;
    }
};
class Solution {
public:
    int directions[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    int encode(int i, int j, int n){
        return i*n+j;
    }
    int numIslands(vector<vector<char>>& grid) {
        int M = grid.size();
        if(M==0)
            return 0;
        int N = grid[0].size();
        if(N==0)
            return 0;
        UnionFind UF(M*N);
        for(int i = 0; i < M; i++){
            for(int j = 0; j < N; j++){
                if(grid[i][j]=='1'){
                    for(int d = 0; d < 4; d++){
                        int di = directions[d][0];
                        int dj = directions[d][1];
                        if(i+di >=0 && i+di < M && j+dj >=0 && 
                           j+dj < N && grid[i+di][j+dj]=='1'){
                            UF.Union(encode(i, j, N), encode(i+di, j+dj, N));
                        }
                    }
                }
            }
        }
        int res = 0;
        for(int i = 0; i < M; i++){
            for(int j = 0; j < N; j++){
                if(grid[i][j]=='1'){
                    int id = encode(i, j, N);
                    if(UF.Find(id) == id)
                        res++;
                }
            }
        }
        return res;
    }
};

LeetCode 684. Redundant Connection

题目描述

在这个问题中，树是一个连接的无向图，没有环。

给定输入是以具有N个节点（具有不同值1,2，…，N）的树开始的图，其中添加了一个附加边。添加的边有两个不同的顶点，从1到N中选择，并且不是已经存在的边。

得到的图形作为2D边缘阵列给出。边的每个元素是一对[u，v]，其中u <v，表示连接节点u和v的无向边。

返回可以删除的边，以便生成的图是N个节点的树。如果有多个答案，则返回给定2D阵列中最后出现的答案。答案边[u，v]应采用相同的格式，u <v。

样例

输入: [[1,2], [2,3], [3,4], [1,4], [1,5]]
输出: [1,4]
说明: 给出的例子的图长这样，加上了[1,4]边以后就出现了1-2-3-4的环，所以1-4边是冗余的，所以是答案
5 - 1 - 2
    |   |
    4 - 3

代码

class UnionFind{
public:
    vector<int>father;
    UnionFind(int num){//num表示元素的个数
        for(int i = 0; i < num; i++){
            father.push_back(i);//箭头指向自己
        }
    }
    int Find(int n){
        //递归
        if(father[n] == n)
            return n;
        father[n] = Find(father[n]);//路径压缩版本
        return father[n];
    }
    bool Union(int a, int b){//返回a和b是否本身在一个集合里
        int fa = Find(a);
        int fb = Find(b);
        bool res = fa==fb;
        father[fb] = fa;
        return res;
    }
};

class Solution {
public:
    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
        int N = edges.size();
        UnionFind UF(N+1);
        vector<int>res(2, 0);
        for(int i = 0; i < edges.size(); i++){
            int u = edges[i][0];
            int v = edges[i][1];
            if(UF.Union(u, v)){//冗余
                res[0] = u;
                res[1] = v;
            }
        }
        return res;
    }
};

参考

1. 前面概述部分来自于并查集

2. 后面模板代码部分来自于并查集模板