首页 > 其他分享> 文章详细

Union Find

2021-02-14 23:03:12 阅读：124 来源： 互联网

标签：return Union Find int num parents id public

并查集

Dynamic Connectivity

动态连通性问题，满足：

1.symmetric：自反性

2.transitive:传递性

3.reflexive：对称性

API

QuickFind

public class QuickFind {
    private int[] id;
    public QuickFind(int nums){
        id = new int[nums];
        for(int i = 0; i < id.length ; i++){
            id[i] = i;
        }
    }
    public boolean isConnected(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;
            }
        }
    }

}

刚开始每个元素都与自己连通，进行union(p,q) == 将p 连接到 q上，quickfind将pid全部改为qid。

QuickUnion

public class QuickUnionUF {
    private int[] id;
    public QuickUnionUF(int num){
        id = new int[num];
        for (int i = 0; i < id.length; i++) {
            id[i] = i;
        }
    }
    public int findroot(int i){
        while(id[i] != i){
            i = id[i];
        }
        return i;
    }
    public boolean isConnected(int p , int q){
      return findroot(p) == findroot(q);
    }
    public void union(int p , int q ){
        int proot = findroot(p);
        int qroot = findroot(q);
        id[proot] = qroot;
    }

}

QuickUnion将连通分量抽象成树，用根节点是否一致来判断连通性；

缺陷：数的高度很高，查找根节点操作需要进行多次，速度不快。

Weighted QuickUnion

 1 public class WeightedQuickUnionUF {
 2     private int[] parents;
 3     private int count;
 4     private int[] size;
 5     public WeightedQuickUnionUF(int num){
 6         parents = new int[num];
 7         size = new int[num];
 8         count = num;
 9         for (int i = 0; i < num; i++) {
10             parents[i] = i;
11             size[i] = 1;
12         }
13     }
14     public int find(int p ){
15         while(parents[p] != p){
16             parents[p] = parents[parents[p]];   //路径压缩!!!!
17             p = parents[p];
18         }
19         return p;
20     }
21     public boolean isConnected(int p , int q ){
22         return (parents[p] == parents[q]);
23     }
24     public void union(int p , int q ){
25         if(isConnected(p,q)){
26             return;
27         }else{
28             int pid = find(p);
29             int qid = find(q);
30             if(size[p] <= size[q]){
31                 parents[p] = qid;
32                 size[qid] += size[pid];
33             }else{
34                 parents[q] = pid;
35                 size[pid] += size[qid];
36             }
37             count--;
38         }
39     }
40 }

优点：任意节点x的深度最多为lgN，原因是只有向size更大的节点合并时，树的高度才会+1，因此总共N个节点，最多可以加倍lgN次，高度最高为lgN

标签：return,Union,Find,int,num,parents,id,public
来源： https://www.cnblogs.com/JasonJ/p/14402917.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Union Find