手撕并查集及其优化，三大相关模板实现详解（附图解）-CSDN博客

本文链接：https://blog.csdn.net/qq_63786973/article/details/127030230

文章目录

相关概念及性质
相关操作
模板理解及实现

相关操作

$\color{Green}基本原理$ ：

① 每个集合用一棵树来表示，树根的编号就是整个集合的编号
② 每个节点存储它的 父节点， $p [x]$ 表示 $x$ 的父节点

问题：如何判断树根 ? ? ?

既然 $p [x]$ 表示 $x$ 的父节点，那么当且仅当 $p [x] = x$ 时，我们可以得出节点 $x$ 就是整棵树的树根

1. 查找 - - - 如何求 x 所属的集合编号？？？

顾名思义，就是确定元素 $x$ 属于哪一个集合

实现思路

自底向上，不断查找每个节点的父节点，直到找到它所属集合的根节点

1.1 BF 做法

如同实现思路那样，我们直接自底向上不断查找，直到找到集合的根节点

代码实现

int p[N]; // 存储每个节点的父节点

int find(int x)
{
    if(p[x] == x)  // 如果 p[x] == x, 此时 x 即为 树根
        return x;
   	
    return find(p[x]); // 否则，自底向上继续查找当前节点的父节点
}

1.2 路径压缩优化

当树的高度过高，查询元素的个数过多时， BF 做法的时间效率显得过于吃力，此时我们需要对元素所在集合查询时的路径进行缩短优化，此时均摊的时间复杂度为 O(logn)

思路

所谓 ” 路径压缩 “ ，就是一种在执行 ” 查找 “ 过程中，扁平化树的结构的方法，使得在路径上的每一个节点都可以直接连在根节点上，为以后直接或则间接引用节点的操作加速

$\color{Red}关键$ ：在搜索一遍的同时，将所有节点的父节点都置为根节点

如下图所示，当我们调用 FIND 查找 元素 C 时，递归地，置此路径上的每一个节点的父节点直接指向根节点，正如 元素 C 那样，将原来的 父节点 A 置为 根节点 R，这样当我们在下次查找元素 C 所属的集合时，直接以 O（1） 的时间复杂度找出根节点的编号

在这里插入图片描述

代码模板

int p[x];// 存储每个节点的父节点

int find(int x)
{
    if(p[x] != x) p[x] = find(p[x]); // 递归地查找根节点，并置路径上的所有节点的父节点为根节点
      
    return p[x];// 如果 p[x] == x, 此时 p[x] 即为 树根
}

1.3 按秩合并优化

还有一种优化的方法，叫做 按秩合并，均摊时间复杂度为 O（logn）。如果题目需要维护明确的父子关系而用到了按秩合并的话，是不能用路径压缩的。一旦用了路径压缩，会破坏树的形态，因为原来的节点的父节点会直接压缩到祖先上，这样一来我们调用的时候父子关系发生了改变，造成了算法的错误

$\color{Red}核心$ ：

” 秩 “ ：树的深度（未压缩路径的）OR 集合的大小
合并时，秩较大的树根作为秩较小的树根的 父节点

代码模板

① $\color{Orange}按元素所在集合的大小合并$

void uni(int x, int y)// 按 集合的大小 合并
{
    int px = find(x);
    int py = find(y);
    
    if(px != py) //  秩 较大 的树根 作为 秩 较小 的树根的父节点
    {
        if(size[px] < size[py])  // y 的树根较大 , 则 y 的树根作为 x 树根的父节点
           p[px] = py, size[py] += size[px];
        else
           p[py] = px, size[px] += size[py];
    }
}

② $\color{Orange}按元素所在树的深度合并$

void uni(int x, int y)
{
    int px = find(x);
    int py = find(y);
    
    if(px != py) //  秩 较大 的树根 作为 秩 较小 的树根的父节点
    {
        if(high[px] < high[py]) // y 的树根较大 , 则 y 的树根作为 x 树根的父节点
            p[px] = py;
        else // 包含  > = 的情况
        {
            p[py] = px;
            if(high[px] == high[py])
                high[px] ++; //按深度合并，只有在两树高度相等的时候才更新
        }         
        
    }
}

$\color{Yellow}为什么合并的两棵树深度相同时，新的根节点的深度才要 + 1~~ ？？？$

深度有差异时：
由于我们在合并时，将 深度较大 的树根作为 深度较小 的树根的父节点，因为深度较小的树并不能影响合并后的树的深度，故当两棵树高度有差异时，我们不做处理
深度相等时：
如下图所示，我们有两个深度均为 2 的树，现在要合并这两棵树，这里把R1 的父节点置为R2，显然在合并后，树的高度便增加了 1

在这里插入图片描述

2. 合并 - - - 如何合并两个集合？？？

当我们查找出两个元素所属的集合编号后，进一步就可以确定两个元素是否同属于一个集合

实现思路

① 若属于同一个子集，我们什么都不做
②若 不属于 同一个子集，我们 $\color{Orange}置一个节点的祖宗节点（根节点）的父节点，为另一个节点的祖宗节点$

如下图所示，当我们合并 元素 A和 元素 B 所在的集合时，我们找到其中一个元素（这里我取 元素A）所属集合的根节点R1，以及另一个元素（这里我取 元素B）所属集合的根结点R2，及将R1的父节点置为R2 ，即 $\textcolor{Yellow}{p[~find(A)~] = find(B)}$

在这里插入图片描述

模板理解及实现

以下代码模板在此均采用路径压缩优化

朴素并查集

正如名字所示那样，我们只实现并查集的基本功能，即查找和合并，不维护其他的信息

代码模板

int p[N];// 储存每个节点的祖宗节点

// 返回 x 的祖宗节点
int find(int x)
{
    if(p[x] != x) return p[x] = find(p[x]);
    
    return p[x];
}

//  初始化， 假定 节点编号是 1 ~ n
for(int i = 1; i <= n; i ++ )
{
    p[i] = i;// 初始化时，我们将各个节点的父节点置为本身
}

// 合并 元素 x 和 元素 y 所在的两个集合
p[find(x)] = find(y);

维护 Size 的并查集

思路

如下图所示，当我们合并 元素 x ，元素 y所在集合时，将元素 x 的所在集合的祖宗节点的父节点置为 元素 y 所在集合的祖宗节点，并使 元素y所在集合的大小加上 元素 x所在集合的大小，即 $\color{Yellow}size[find(x)] += size[find(x)]$

代码模板

int p[N]; // p[] 存储每个节点的祖宗节点
int size[N]; // size[] 只有祖宗节点的有意义，表示祖宗节点所在集合中的节点的数量

// 返回 x 的祖宗节点
int find(int x)
{
    if(p[x] != x)  p[x] = find(p[x]);
    
    return p[x];
}

// 初始化，假定节点的编号是 1 ~ n
for(int i = 1;i <= n; i ++ )
{
    p[i] = i; // 初始化时，我们将各个节点的父节点置为本身
    size[i] = 1; // 只有 i 本身一个元素
}

//合并 元素 x 和元素 y 所在的两个集合
p[find(x)] = find(y);
size[find(x)] += size[find(y)];

维护到祖宗节点距离的并查集

思路

如下图所示，当进行路径压缩过程中，我们将 元素x 的父节点置为祖宗节点的同时，将 元素x 到父节点的距离d[x] 置为 d[x] + d[px] ，即 $\color{Yellow}d[x] += d[p[x]]$

在这里插入图片描述

代码模板

int p[N];// p[] 存储每个节点的祖宗节点
int d[N];// d[x] 储存 x 到 其父节点 p[x] 的距离

//返回 x 的祖宗节点
int find(int x)
{
    if(p[x] != x) 
    {
        int u = find(p[x]);
        d[x] += d[p[x]];
        p[x] = u;
        
    }
    
    return p[x];
   
}

// 初始化，假定节点的编号是 1 ~ n
for(int i = 1;i <= n; i ++ )
{
    p[i] = i; // 初始化时，我们将各个节点的父节点置为本身
    size[i] = 1; // 只有 i 本身一个元素
}

//合并 元素 x 和元素 y 所在的两个集合
p[find(x)] = find(y]);
d[find(x)] = distance; // 根据具体问题而定，初始化find(x) 的偏移量