【模板】并查集

并查集（Disjoint Set）是一种非常精巧而实用的数据结构，用于处理不相交集合的合并问题。

1.并查集是什么

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

• 查询元素 $a$ 和元素 $b$ 是否属于同一组。

• 合并元素 $a$ 和元素 $b$ 所在的组。

不过需要注意的是，并查集虽然可以进行合并操作，但是却无法进行分割操作。

2.并查集的结构

并查集是使用树形结构实现的，不过，不是二叉树。

每个元素对应一个节点，每个组对应一棵树。在并查集中，哪个节点是哪个节点的父亲以及树的形状等信息无需多加关注，整体组成一个树形结构才是重要的。

2.1 初始化

我们准备 $n$ 个节点来表示 $n$ 个元素，每个元素属于单独的一个集合，即每个元素以自己作为自己的根节点，也就是说，最开始时没有边。

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

// 初始化，假定节点编号是1~n
void init()
{
    for (int i = 1; i <= n; i++)
    {
        f[i] = i;
    }
}

2.2 查询

为了查询两个节点是否属于同一组，我们需要沿着树向上走，来查询包含这个元素的树的根是谁。如果两个节点走到了同一个根，那么就可以知道它们属于同一组。

在下图中，元素 $2$ 和元素 $5$ 都走到了元素 $1$，因此它们属于同一组。另一方面，由于元素 $7$ 走到的是元素 $6$，因此同元素 $2$ 或元素 $5$ 属于不同组。

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

2.3 合并

像下图一样，从一个组的根向另一个组的根连边，这样两棵树就变成了一棵树，也就把两个组合并为一个组了。

void unite(int x, int y)
{
    x = find(x);
    y = find(y);
    if (x != y)
    {
        f[x] = y;
    }
}

在树形数据结构里，如果发生了退化的情况，那么复杂度就会变得很高。因此，有必要想办法避免退化的发生。

3.路径压缩

对于每个节点，一旦向上走到了一次根节点，就把这个点到父亲的边改为直接连向根。

在此之上，不仅仅是所查询的节点，在查询过程中向上经过的所有的节点，都改为直接连到根上。这样再次查询这些节点时，就可以很快知道根是谁了。

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

4.按秩合并

对于每棵树，记录这棵树的高度（rank）。

合并时如果两棵树的 rank 不同，那么从 rank 小的向 rank 大的连边。

下面代码加入了路径压缩和按秩合并这两个优化，我们用编号代表每个元素，在初始化时用一个 rank 数组定义每个元素的高度，在合并时更改。

int f[N]; // 存储每个点的祖宗节点
int rank[N]; // 树的高度

// 初始化，假定节点编号是1~n
void init()
{
    for (int i = 1; i <= n; i++)
	{
	    f[i] = i;
	    rank[i] = 0;
	}
}

// 查询树的根（路径压缩）
int find(int x)
{
    if (f[x] == x)
    {
        return x;
    }
	else
	{
	    return f[x] = find(f[x]);
	}
}

// 合并x和y所属的集合（按秩合并）
void unite(int x, int y)
{
    x = find(x);
    y = find(y);
    if (x == y) return;
    
	if (rank[x] < rank[y])
	{
	    f[x] = y;
	}
	else
	{
	    f[y] = x;
	    if (rank[x] == rank[y])
	    {
	        rank[x]++;
	    }
	}
}

加入了路径压缩和按秩合并这两个优化之后的并查集效率非常高。对 $n$ 个元素的并查集进行一次操作的复杂度是 $O(\alpha (n))$。在这里，$\alpha (n)$ 是阿克曼函数的反函数。这比 $O(\log (n))$ 还要快。

不过，这是“均摊复杂度”。也就是说，并不是每一次操作都满足这个复杂度，而是多次操作之后平均每一次操作的复杂度是 $O(\alpha (n))$ 的意思。