开个新坑, 准备学习算法(第四版), 并把上面学到的东西写成博客, 毕竟以前也学过一点算法, 但效果甚微
并查集, 在这本书的第一章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 }
完成!
原文地址：https://www.cnblogs.com/qq1914808114/p/10765873.html