为什么并查集在路径压缩之后的时间复杂度是阿克曼函数

并查集在路径压缩之后的时间复杂度是阿克曼函数的原因：有n个元素、m个操作的并查集的时间复杂度一般是O(m log n)，而路径压缩操作会导致树的形状发生变化，因此其时间复杂度可以看作是一个与节点数有关的递归函数，也就是阿克曼函数。

一、并查集在路径压缩之后的时间复杂度是阿克曼函数的原因

首先，需要明确一下，在并查集中，路径压缩操作是在查询（find）操作中完成的。其基本思想是在查询时顺便把经过的所有节点都直接连接到根节点上，以减小后续查询的时间复杂度。

然后，我们可以通过一个公式来计算出并查集在路径压缩之后的时间复杂度：

T(n) <= T(n-1) + O(1)

其中，T(n) 表示 n 个元素的并查集在路径压缩之后的时间复杂度，O(1) 是指单次路径压缩操作的时间复杂度为常量。

这个公式的意义是：n 个元素的并查集在路径压缩之后的时间复杂度不会超过 n-1 个元素的并查集在路径压缩之后的时间复杂度加上单次路径压缩操作的时间复杂度。

接下来，我们可以通过数学归纳法证明 T(n) 的上界就是阿克曼函数。

当 n=1 时，显然 T(1) = O(1)，成立。

假设当 n=k (k>=1) 时，T(k) <= A(m, n)，其中 m 和 n 都是小于等于 k 的正整数，A(m, n) 是阿克曼函数值。

现在来考虑 n=k+1 的情况。由于 k+1 个元素的并查集可以看作是两个并查集的合并，因此有：

T(k+1) <= T(i) + T(k+1-i) + O(1)

其中 i 表示第一个并查集中的元素数量，满足 1<=i<=k。

根据归纳假设，T(i) 和 T(k+1-i) 都不超过 A(m, n)，因此有：

T(k+1) <= 2A(m, n) + O(1)

实际上，这也就证明了 n 个元素的并查集在路径压缩之后的时间复杂度是阿克曼函数级别的。因为阿克曼函数增长极快，所以并查集在路径压缩之后的时间复杂度非常优秀。

二、并查集详解

并查集是一种用于管理元素所属集合的数据结构，实现为一个森林，其中每棵树表示一个集合，树中的节点表示对应集合中的元素。

顾名思义，并查集支持两种操作：

• 合并（Union）：合并两个元素所属集合（合并对应的树）。
• 查询（Find）：查询某个元素所属集合（查询对应的树的根节点），这可以用于判断两个元素是否属于同一集合

并查集在经过修改后可以支持单个元素的删除、移动；使用动态开点线段树还可以实现可持久化并查集。

1、初始化

初始时，每个元素都位于一个单独的集合，表示为一棵只有根节点的树。方便起见，我们将根节点的父亲设为自己。

代码实现（c++）：

struct dsu {
  vector<size_t> pa;

  explicit dsu(size_t size) : pa(size) { iota(pa.begin(), pa.end(), 0); }
};

2、查询

我们需要沿着树向上移动，直至找到根节点。

代码实现（c++）：

size_t dsu::find(size_t x) { return pa[x] == x ? x : find(pa[x]); }

3、路径压缩

查询过程中经过的每个元素都属于该集合，我们可以将其直接连到根节点以加快后续查询。

代码实现（c++）：

size_t dsu::find(size_t x) { return pa[x] == x ? x : pa[x] = find(pa[x]); }

4、合并

要合并两棵树，我们只需要将一棵树的根节点连到另一棵树的根节点。

代码实现（c++）：

void dsu::unite(size_t x, size_t y) { pa[find(x)] = find(y); }

5、启发式合并

合并时，选择哪棵树的根节点作为新树的根节点会影响未来操作的复杂度。我们可以将节点较少或深度较小的树连到另一棵，以免发生退化。

代码实现（c++）：

struct dsu {
  vector<size_t> pa, size;

  explicit dsu(size_t size_) : pa(size_), size(size_, 1) {
    iota(pa.begin(), pa.end(), 0);
  }

  void unite(size_t x, size_t y) {
    x = find(x), y = find(y);
    if (x == y) return;
    if (size[x] < size[y]) swap(x, y);
    pa[y] = x;
    size[x] += size[y];
  }
};

6、删除

要删除一个叶子节点，我们可以将其父亲设为自己。为了保证要删除的元素都是叶子，我们可以预先为每个节点制作副本，并将其副本作为父亲。

代码实现（c++）：

struct dsu {
  vector<size_t> pa, size;

  explicit dsu(size_t size_) : pa(size_ * 2), size(size_ * 2, 1) {
    iota(pa.begin(), pa.begin() + size_, size_);
    iota(pa.begin() + size_, pa.end(), size_);
  }

  void erase(size_t x) {
    --size[find(x)];
    pa[x] = x;
  }
};

7、移动

与删除类似，通过以副本作为父亲，保证要移动的元素都是叶子。

代码实现（c++）：

void dsu::move(size_t x, size_t y) {
  auto fx = find(x), fy = find(y);
  if (fx == fy) return;
  pa[x] = fy;
  --size[fx], ++size[fy];
}

延伸阅读

并查集的按秩合并优化法简介

并查集除了可以用路径压缩法优化外，还可以用按秩合并法优化。按秩合并就是在对两个不同子集连接时，按照rank来连，也就是rank低的连在rank高的下面。rank高的做父亲节点，这样类似维护了一棵树，树是rank高的在上。因为路径压缩法优化程度更高，所以一般情况下使用路径压缩法。但是路径压缩法会破坏树的结构，在不想破坏树的结构的情况下，可以使用按秩合并法。