并查集算法：Union-Find

并查集算法：Union-Find

一.算法简介

并查集算法是为了解决一类连通性的问题，连通是一种等价关系，满足自反性，对称性和传递性。
- 自反性：p和p是连通的
- 对称性：假设p和q是连通的，那么q和p也是连通的
- 传递性：假设p和q是连通的，q和r也是连通的，那么可以推出p和r也是连通的

从连通性这种等价关系，我们可以将对象划分成等价类，等价类中的任意两个元素都是连通的。

二.API设计

并查集通常有这么几个API：

API	功能
void init(int N)	使用0~N-1初始化对象
void union(int p, int q)	在p和q之间添加一条连接
int find(int p)	找到p的标识符
bool connected(int p, int q)	判断p和q之间是否存在连接
int count()	求连通分量的个数

1.初始化API：init

假设有N个对象，通常情况下，我们将其标识符id初始化为0~N-1：

void init(int N) {
    for(int i = 0; i < N; ++i) {
        id[i] = i;
    }
    return;
}

id可以设置为一个数组或者vector，至于是将其设置位全局变量，还是以参数形式传递到init函数，取决于个人和问题。
另外利用SGI STL的iota函数：（iota代表了古希腊字母ι，具体含义见what-does-iota-of-stdiota-stand-for
）

iota(id.begin(), id.end(), 0);
//或者
iota(id, id + N, 0);

也简单介绍一下iota函数的实现吧!

template<class ForwardIterator, class T>
void iota(ForwardIterator first, ForwardIterator last, T value) {
    while(first != last) *first++ = value++;
}

当然，有时初始化并不是将其初始化为0~N-1，就像我们在本文后面举的两个例子，有些未满足条件的对象，我们直接初始化为-1。这个依据问题发生改变。

2. union & find

(1). quick-find算法
只要保证id[p]==id[q]，那么p和q就是连通的。

int find(int p) { return id[p]; }
bool connected(int p, int q) { return id[p] == id[q]; }

union算法只需要将两个对象归到相同的分量中即可：

viod union(int p, int q) {
    int p_id = find(q), q_id = find(q);
    if(p_id == q_id) return;
    for(int i = 0; i < N; ++i) {
        if(id[i] == q_id)
            id[i] = p_id;   //将所有的与q连通的对象都归到p的连通分量去
    }
}

这个算法的优点在于find的操作是常数时间，缺点也很明显：每次union都要遍历一遍id，因此无法处理大型问题。
下面介绍改进的算法：
(2). quick-union算法
从字面意思看，就知道quick-union算法是为了提高union的效率。
quick-union算法的思路在于id意义的改变，假设得到id[p]，这个时候id[p]的含义并不是标识位，而仍然是对象的编号，必须从这个对象又继续深入下去，直到满足p=id[p]，这时说明p已经是这个连通分量的根节点。因此以后判断连通性只需要判断两个对象的根节点是否一致就行了。

int find(int p) {
    while(p != id[p]) p =id[p];
    return p;
}
bool connect(int p, int q) {
    return find(p) == find(q);
}
void union(int p, int q) {
    int p_root = find(p), q_root = find(q);
    if(p_root == q_root) return;
    id[q_root] = p_root;    //将q的根节点设为p的根节点
    return;
}

quick-union算法一般情况下(特殊输入无法保证)要比quick-find算法要快，因为不用每次union都遍历id。另外quick-union算法最坏的情况在于所有的对象的根节点相同，而且树高度为N。
(3). 加权quick-union算法
加权quick-union算法是为了改善树高度为N的那种最糟糕的情况，经过加权处理，能够保证树的高度远远小于未加权的树的高度。
需要设置一个数组或者vector来记录树中的节点树，记为sz，且sz中的元素都初始化为1即可。

int find(int p) {
    while(p != id[p]) p =id[p];
    return p;
}
bool connect(int p, int q) {
    return find(p) == find(q);
}
void union(int p, int q) {
    int p_root = find(p), q_root = find(q);
    if(p_root == q_root) return;
    //将小树的根节点连接到大树的根节点
    if(sz[p_root] < sz[q_root]) {
        id[p_root] = q_root;
        sz[q] += sz[p];     //更新大树根节点的sz
    }
    else {
        id[q_root] = p_root;
        sz[p] += sz[q];     //更新大树根节点的sz
    }
}

可以证明的是：加权quick-union算法所构造的树的深度部超过lgN。
(4). 带路径压缩的加权quick-union算法
路径压缩指的是将每个节点都直接链接到其根节点，这样的树就是一颗几乎扁平的树。要实现路径压缩，只需要在find函数中，将路径上的所有节点都直接连接到根节点即可。

void find(p) {
    int p_temp = p;
    while(p != id[p]) p = id[p];    //找到根节点p
    while(p != id[p_temp]) {
        //将路径上的所有节点都直接连接到根节点
        int q = id[p_temp];
        id[p_temp] = p;
        p_temp = q;
    }
    return p;
}

3. count API

count()是为了计算连通分量的个数，思路其实很简单，定义一个变量count初始化为N，每次union之后将count减一即可，最后返回count:

//假设一种union算法
void union(int p, int q) {
    ...//不变，加上最后这一句
    --count;
}
int count() { return count; }

4.举两个例子

例子1：Number of Islands
Given a 2d grid map of ‘1’s (land) and ‘0’s (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
代码如下：

    int Find(vector<int> &id, int p) {
        if (p == -1 || id[p] == -1) return -1;
        int temp = p;
        while (p != id[p]) p = id[p];
        while (temp != id[temp]) {
            int q = temp;
            temp = id[temp];
            id[q] = p;
        }
        return p;
    }
    void Union(vector<int> &id, vector<int> &sz, int p, int q) {
        int p_root = Find(id, p);
        int q_root = Find(id, q);
        if (p_root == q_root) return;
        if (sz[p_root] < sz[q_root]) {
            sz[q_root] += sz[p_root];
            id[p_root] = id[q_root];
        }
        else {
            sz[p_root] += sz[q_root];
            id[q_root] = id[p_root];
        }
        return;
    }
    int numIslands(vector<vector<char>>& grid) {
        if (grid.empty() || grid[0].empty()) return 0;
        int rows = grid.size(), cols = grid[0].size();
        int len = rows * cols;
        vector<int> id(len), sz(len, 1);
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                id[i * cols + j] = grid[i][j] == '1' ? i * cols + j : -1;
            }
        }
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                int pos = i * cols + j;
                if (id[pos] != -1 && i + 1 < rows && id[pos + cols] != -1) {
                    Union(id, sz, pos, pos + cols);
                }
                if (id[pos] != -1 && j + 1 < cols && id[pos + 1] != -1) {
                    Union(id, sz, pos, pos + 1);
                }
            }
        }
        map<int, int> my_map;
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                int pos = i * cols + j;
                if (id[pos] != -1) ++my_map[Find(id, pos)];
            }
        }
        return my_map.size();
    }

Find和Union操作和我们上面的写的API基本一致，只是将初始化函数Init放到numIslands接口内部。基本思路就是:从左到右，从上到下，依次union满足条件的两个lands，最后根据根节点的个数(通过map)来计算island的个数。

例子2：机器人的运动范围：
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
这个问题也可以用并查集来做，下面是代码实现：

//机器人的运动范围
bool IsVaildVal(int x, int y, int threshold) {
  int result = 0;
  while (x) {
    result += x % 10;
    x /= 10;
  }
  while (y) {
    result += y % 10;
    y /= 10;
  }
  return result <= threshold;
}
int Find(vector<int> &id, int p) {
  if (p == -1 || id[p] == -1) return -1;
  int temp = p;
  while (p != id[p]) p = id[p];
  while (p != id[temp]) {
    int q = id[temp];
    id[temp] = p;
    temp = q;
  }
  return p;
}
void Union(vector<int> &id, vector<int> &sz, int p, int q) {
  int p_root = Find(id, p);
  int q_root = Find(id, q);
  if (p_root == q_root) return;
  if (sz[p_root] < sz[q_root]) {
    sz[q_root] += sz[p_root];
    id[p_root] = id[q_root];
  } else {
    sz[p_root] += sz[q_root];
    id[q_root] = id[p_root];
    }
    return;
}
int movingCount(int threshold, int rows, int cols) {
    if(rows <= 0 || cols <= 0) return 0;
  vector<int> id(rows * cols), sz(rows * cols, 1);
  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
      //将不满足坐标和的id值设为-1，否则设为其下标
      id[i * cols + j] = IsVaildVal(i, j, threshold) ? i * cols + j : -1;
    }
  }
  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
            int pos = i * cols + j;
      if (id[pos] != -1 && i + 1 < rows && id[pos + cols] != -1)
                Union(id, sz, pos, pos + cols);
      if (id[pos] != -1 && j + 1 < cols && id[pos + 1] != -1)
                Union(id, sz, pos, pos + 1);
        }
    }
    int count = 0;
    int base_id = Find(id, 0);
  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j) {
      int pos = i * cols + j;
      if (id[pos] != -1 && Find(id, pos) == base_id)
                ++count;
        }
    }
    return count;
}

5.各类算法性能特点

算法	Init	Union	Find
quick-find	O(N)	O(N)	O(1)
quick-union	O(N)	O(树高度)	O(树的高度)
加权quick-union	O(N)	O(lgN)	O(lgN)
压缩路径加权quick-union	O(N)	接近O(1)	接近O(1)
理想情况	O(N)	O(1)	O(1)

压缩路径加权quick-union算法已经是这类算法中最优的算法了，理想情况的算法还没有人发现。

主要参考自《算法(第四版)》Robert Sedgewick & Kevin Wayne著，谢路云译。

非常棒的一本书，很多人都极力推荐的算法入门书。