算法(第四版)之并查集(union-find算法)

Posted 2021-10-23 qq1914808114

 

开个新坑, 准备学习算法(第四版), 并把上面学到的东西写成博客, 毕竟以前也学过一点算法, 但效果甚微

并查集, 在这本书的第一章1.5中叫做union-find算法, 但在其他地方这个叫做并查集,就是说一系列点的连通问题,比如, 我们有十个点, 分别记作0~9:

加入我们要把2和4连接起来怎么表示呢? 首先我们会想到,给所有的点标上一个号, 来代表他们的连通关系, 我们初始化这个数就是他们id本身:

如果我们要连接2和4, 就使得4的id为2:

之后要连接间隔点任意两个点, 就把它们和它们相应的点的值都设置为一样就行了, 如果我们要比对这两个是是否连通, 也只要比较他们的值是否相等就行了.

我们可以很轻易的写出下面的代码:

 1 /*
 2 * 并查集实现程序
 3 */
 4 public class UF {
 5     private int[] id;
 6     private int count; //连通图的个数
 7 
 8     public UF(int N) { // 构造方法
 9         id = new int[N];
10         for(int i = 0; i < N; i++) {
11             id[i] = i;
12         }
13         count = N;
14     }
15 
16     public void union( int p, int q) { // 连接两个点
17         int pId = find(p);
18         int qId = find(q);
19         if(pId == qId)  // 已连接则不执行任何操作
20             return;    
21         for(int i : id) {
22             if(id[i] == pId)
23                 id[i] = qId;
24         }
25         count--; // 连通图数减1
26     }
27 
28     public  int find(int i) { // 查找点i所在分量的标识符
29         return id[i];
30     }
31 
32     public boolean connected(int p, int q) { // 查看亮点是否连通
33         return find(p) == find(q);
34     }
35 
36     public int getCount() { // 获得连通图的个数
37         return count;
38     }
39 
40 }

这就是树上的quick-find算法. 但是, 问题来了, 这样我们查找两个点是否连通很方便, 速度很快, 但是连接两个点就很慢了--我们需要遍历所有的点! 在例子中我们只有十个点, 可是若有几百万个点呢? 每操作一次就遍历上百万个点, 这样我们的代码肯定就会无比的慢, 所以, 我们必须想新的办法.

这是, 我们有了新的方法,就是书上的quick-union算法, 就是说, 我们每次连接两个点时, 只改变一个点的标识值, 也就形成了一棵棵树, 这样在一个连通图中就肯定有一个值的标识值是它本身的id, 没有发生改变, 当我们用查找find()方法查找时,只要一直往下找, 直到找到标识值为它本身的这个点就行, 这样就不会每次都遍历到所有的点,  总体上来说时间复杂度就降下来了:

我们也可以轻易地写出相应的代码:

 1 public void union( int p, int q) { // 连接两个点
 2             int rp = find(p);
 3             int rq = find(q);
 4             if(rq == rp)
 5                 return;
 6             if(sz[rp] < sz[rq]) {
 7                 id[rp] = rq;
 8                 sz[rq] += sz[rp];
 9             } else {
10                 id[rq] = rp;
11                 sz[rp] += sz[rq];
12             }
13             count--;
14     }
15 
16     public  int find(int i) { // 查找该点的根节点
17         while(id[i] != i)
18             i = id[i];
19         return i;
20     }

 

 

 但是, 还不够, 因为我们得考虑最坏的情况, 就是当我们形成的这棵数没有分支, 也就是形成了一条链时, 我们就依然变成了需要遍历所有的点, 这样, 我们辛辛苦苦降下去的佛咋读有回来了

 

 

然后, 我们就有了书上的加权的quick-union算法, 就是将树的高度记录下来, 然后每次union()时把高度低的数加到高度高的树上去, 这样树的高度就不会超过lgN, 时间复杂度也控制在了O(lgN), 代码如下:

 1 /*
 2 * 并查集实现程序
 3 */
 4 public class UF {
 5     private int[] id;
 6     private int count; //连通图的个数
 7     private int sz[];
 8 
 9     public UF(int N) { // 构造方法
10         id = new int[N];
11         sz = new int[N];
12         for(int i = 0; i < N; i++) {
13             id[i] = i;
14             sz[i] = 1;
15         }
16         count = N;
17     }
18 
19     public void union( int p, int q) { // 连接两个点
20             int rp = find(p);
21             int rq = find(q);
22             if(rq == rp)
23                 return;
24             if(sz[rp] < sz[rq]) {
25                 id[rp] = rq;
26                 sz[rq] += sz[rp];
27             } else {
28                 id[rq] = rp;
29                 sz[rp] += sz[rq];
30             }
31             count--;
32     }
33 
34     public  int find(int i) { // 查找根节点
35         while(id[i] != i)
36             i = id[i];
37         return i;
38     }
39 
40     public boolean connected(int p, int q) { // 判断两个点书否连接
41         return find(p) == find(q);
42     }
43 
44     public int getCount() {
45         return count;
46     }
47 
48 }

 

当然, 我们再有办法优化, 我们的目标当然是无限接近常数次操作, 也就是O(1), 虽然这是不可能的. 那么, 我们还能怎么优化呢? 这就是,路径压缩, 就是说在调用find()方法时同时加一个循环, 将所有的这些点直接指向根节点, 这样我们下次操作这些点不就是常数次操作了嘛! 代码如下:

 1     public  int find(int i) { // 查找根节点
 2         while(id[i] != i)
 3             i = id[i];
 4         int j = i;
 5         while(id[j] != j) {
 6             int tmp = j;
 7             j = id[j];
 8             id[tmp] = i; // 将其直接与根节点相连
 9         }
10     　　return i;
11     }

在最后, 附送下最后的完整代码:

 1 /*
 2 * 并查集实现程序
 3 * 使用路径压缩的加权quit-union算法
 4 */
 5 public class UF {
 6     private int[] id;
 7     private int count; //连通图的个数
 8     private int sz[];
 9 
10     public UF(int N) { // 构造方法
11         id = new int[N];
12         sz = new int[N];
13         for(int i = 0; i < N; i++) {
14             id[i] = i;
15             sz[i] = 1;
16         }
17         count = N;
18     }
19 
20     public void union( int p, int q) { // 连接两个点
21             int rp = find(p);
22             int rq = find(q);
23             if(rq == rp)
24                 return;
25             if(sz[rp] < sz[rq]) {
26                 id[rp] = rq;
27                 sz[rq] += sz[rp];
28             } else {
29                 id[rq] = rp;
30                 sz[rp] += sz[rq];
31             }
32             count--;
33     }
34 
35     public  int find(int i) { // 查找根节点
36         while(id[i] != i)
37             i = id[i];
38         int j = i;
39         while(id[j] != j) {
40             int tmp = j;
41             j = id[j];
42             id[tmp] = i; // 将其直接与根节点相连
43         }
44         return i;
45     }
46 
47     public boolean connected(int p, int q) {
48         return find(p) == find(q);
49     }
50 
51     public int getCount() {
52         return count;
53     }
54 
55 }

完成!