Quick Find

直觉描述

有种问题叫动态联通性问题。

动态联通性：简单

比如上图中的节点图，可以看到其中一部分被直接或间接连接起来了，比如：

(0, 1), (1, 2), (5, 6), (6, 7)

但有些没有，比如：

(2, 3), (0, 9)

如果现在我问你，这些节点中的某两个点是否连起来了？看起来不是个问题，除非问题变成如下图的形式。

动态联通性：复杂

这个问题就不那么容易回答了对吧？如果想自己试试，需要花不少时间。如果把每一个节点想象为一个计算机，我现在有100万台机器，问其中某几台是否连接，甚至都不大可能会是个可以手动解决的问题。

问题建模

首先，对于联通，需要知道其有三个特性：

• 自连：(0, 0)是合法的连接；
• 对称：如果(0, 1)存在，那么(1, 0)也存在；
• 传递：如果(0, 1)和(1, 2)都存在，那么(0, 2)也存在；

有了这个前提，我们再来分解一下这个问题，转换为可解的题目。

已知条件：

数据的格式为一系列的节点，为了简便行事，我们就用index来标注它们。

[0, 1, 2, 3...N]

给出现有连接状态。如上面的简单示例，我们用union来描述两个节点之间曾经进行的连接行为。

union(0, 1), union(1, 2), union(0, 5), union(1, 6), 
union(2, 7), union(3, 4), union(3, 8), union(4, 9)

求：

对于已知的两个节点m, n，它们是否联通？
connected(m, n): Boolean

Quick Find

现在来想办法解决这个问题。Quick Find利用的是index。

针对每一个union，我们就用相同的index标注这两个节点（及其同组成员），直到结束。

• 原数据index
  [0, 1, 2, ...N]
• 连接
  union(0, 1)
• 更新后的index
  [0, 0, 2, ...N]

那么比如说之前简单的联通性问题，可能在所有union完成后，index会更新为如下情形：
[0, 0, 0, 3, 3, 0, 0, 0, 3, 3]
之所以是可能，是因为我们在重新赋值index的时候，可能按照不同的原则，选择了不同的index来更新，比如也可以是如下的形式：
[1, 1, 1, 8, 8, 1, 1, 1, 1, 1]
这个需要特别在标注index时注意，union(m, n)意味着m和n所对应的阵营合并了，而不仅仅是节点本身。

完成标注后，如果我们想知道0和9这两个节点是否连接，我们可以:
connected(0, 9)
实现的形式为：
查询0和9的index，看其是否相等，如果是则返回true，否则false

复杂度

这种方法做了如下步骤：

• 建立index并初始化
• 记录每个union：
• 查询联通性

在这里，我们暂且将复杂度这个概念简单等同为访问了index的次数。结合如下代码，我们来看看这个算法需要多少复杂度。

public class QuickFindUF
{
    private int[] id;
    public QuickFindUF(int N)
    {
        id = new int[N];
        for (int i = 0; i < N; i++)
          id[i] = i;
    }
    public boolean connected(int p, int q)
    { return id[p] == id[q]; }
    public void union(int p, int q)
    {
        int pid = id[p];
        int qid = id[q];
        for (int i = 0; i < id.length; i++)
          if (id[i] == pid) id[i] = qid;
    }
}

建立index并初始化

用到的是constructor中的for循环，即：

for (int i = 0; i < N; i++)
    id[i] = i;

很明显，这里访问了index对象N次。

记录每个union

这里用到的是union方法，该方法也有一个for循环。

最坏的情况，比如对于[0, 0, 0, 0, ...0]这样的index对象，union(0, 8)会遍历index中的每一个元素，并且改写其id，所以分解该方法的每一步，我们可以知道：

int pid = id[p]; //1次
int qid = id[q]; //1次
for (int i = 0; i < id.length; i++) //N次
    if (id[i] == pid) //1次
      id[i] = qid; //1次

总共访问了1 + 1 + N * (1 + 1) = 2 + 2N次。

查询联通性

这里用到的是connected方法：

public boolean connected(int p, int q)
    { return id[p] == id[q]; }

可以看到，==两端各一次访问，因此总次数是2次。

是否经济

简单做一下分析，如果我们有N个节点，其中预设有M个连接，现在要查询P组节点的联通性情况，我们需要多少计算量？

• 初始化：N
• union：N*M
• 查询：P

初始化和查询都还好，问题出在union这里。简单期间，假设M = N。N²意味着什么？

• 1000个节点需要1,000,000计算量；
• 100,000个节点需要10,000,000,000计算量；

计算量以指数形式上升，听起来就不是件好事。到底怎么不好？我们换个方式说：

• 当代计算机的能力大概是每秒10⁹次的计算(访问数据的)能力；
• 如果我们在内存有10⁹个单词要处理（访问）；
• 处理时间为1秒；
• 随着内存不断增大，如果计算能力也线性增大，那么处理时间会保持不变；
• 10¹⁹ 内存匹配 10¹⁹运算力的CPU，满内存运算依旧是1秒；

好，那么对于Quick Find的问题：

• 假设N=10⁹，我们需要N²的访问；
• 计算机每秒10⁹的访问/计算能力以及内存；
• 所需时间为10⁹秒 = 30年；
• 如果计算机能力同上升级，10¹⁹内存匹配10¹⁹运算力的CPU，满内存运算会变为10¹⁹秒 = 3000亿年左右。这里比较神经的一点是，我计算机能力提高了10¹⁰倍的前提下，满内存运算居然慢了这么多？？

指数膨胀的算法，确实不好，是因为它无法规模化，规模越大，效率越低。

用个很恶心的例子，如果我养猪，养1头需要100斤饲料/年，养10头需要1000斤是合理的；但如果有人告诉你养10头需要10,000斤饲料，养100头需要1,000,000，这样的只怕没人养猪，或者让猪改吃垃圾更合理？