Dynamic Connectivity Problem（动态连通性问题）

1. 概念

• 触点：区域内的点
• 连接：点与点之间的连接。
• 分量：区域内部分相互连通的所有点构成一个分量，整个区域可以划分为多个分量（包含互相联通的点）

概念 举例 触点 0、1、2…… 连接 0-1，1-2，3-4…… 分量 {0、1、2、5、6、7}，{3、4、8、9}

2. API

public class UF UF 构造方法 int find(p) 找到当前触点p所属分量 void union(p,q) 将p，q合并到同一分量 boolean connected(p,q) 验证p，q是否属于同一分量 int count() 计算当前分量个数

find和union方法是决定算法运算量的重点

3. 模型实现

代码

import edu.princeton.cs.algs4.StdIn;import edu.princeton.cs.algs4.StdOut;public class UF {    private int[] id;    private int count;    public UF(int N){        for(int i=0;i<N;i++){            id[i]=i;        }    }    //见后章节    public int find(int p){}    public void union(int p,int q){}    public boolean connected(int p,int q){        return find(p)==find(q);    }    public int count(){        return count;    }    public static void main(String[] args){        int N = StdIn.readInt();        UF uf = new UF(N);        while(!StdIn.isEmpty()){            int p = StdIn.readInt();            int q = StdIn.readInt();            if(uf.connected(p,q)){                continue;            }            uf.union(p,q);            StdOut.printf(p+" "+q);//打印出来的都是原本没联通，刚刚建立联通的        }        StdOut.printf(uf.count()+"components");    }}

4. quick-find算法

• find及union方法代码

//QuickFind算法    public int find(int p){        return id[p];//find只需要一步    }    public void union(int p,int q){        int pid = find(p);        int qid = find(q);        if(pid == qid){return;}        //数据量最大处        for(int i=0;i<id.length;i++){            if(id[i] == pid){id[i] = qid;}        }        count--;    }

• 特点：find速度快，union速度慢
• 思路：id标号储存触点编号，id内容储存分量编号，find指令只需要返回id特定标号下的内容。union指令将id中内容变更即可。
• 缺点：quick-find算法属于N方级算法，运行速度慢。find方法已经满足要求，但是union方法对数组的访问较大，需要提出一种新的方法来减小union方法的计算量。
  
  

5. quick-union算法

• find及union方法代码

 //QuickUnion算法    public int find(int p){        //数据量最大处        while(id[p]!=p){p=id[p];}        return p;    }    public void union(int p,int q){        int pid = find(p);        int qid = find(q);        if(pid==qid){return;}        id[pid]=qid;//union只需要一步        count--;    }

• 特点：find速度慢，union速度快。与quick-find算法相比，减少了中union操作遍历整个·数组的计算量。使用单链表可以排除无关元素无需进行遍历搜索，减少了union的计算量
• 思路：id标号储存触点编号，id内容储存上级触点编号，find指令使用循环返回p最上层根触点编号，union指令使p的根节点指向q的根节点
• 缺点：虽然使用单链表方式能够大大减少union方法的计算量，但是这种方式也在一定程度上增大了find方法的计算量。如果在union过程中出现瘦高树，则会大大加大find的运算量，所以在实际运算过程中，quick-union算法的实际效率并不一定比quick-find算法效率高。因此如果有一种能够解决瘦高树问题的算法，则find和union方法的效率都将大大提升。

6. 加权quick-union算法

• find及union方法代码以及sz定义

    private int[] id;    private int count;    private int[] sz;//代表根节点引领树的大小(非根节点处数字没有意义)    public WeightedQuickUnionUF(int N){        count = N;        id = new int[N];        for(int i=0;i<N;i++){id[i]=i;}        sz = new int[N];        for(int i=0;i<N;i++){sz[i]=1;}    }    //加权QuickUnion算法    public int find(int p){        while(id[p]!=p){p=id[p];}        return p;    }    public void union(int p,int q){        int pid = find(p);        int qid = find(q);        if(pid==qid){return;}        if(sz[pid]<sz[qid]){ id[pid]=qid; sz[qid]=sz[pid]+sz[qid];}        else{ id[qid]=pid; sz[pid]=sz[pid]+sz[qid];}        count--;    }

• 特点：对于N个节点，树高最大为lgN，相比quick-union算法，加权quick-union算法避免了瘦高树的形成，减少了find方法的计算量，同时union方法计算量与quick-union算法的union方法计算量类似，提高了效率
• 思路：为了保证不会生成瘦高树，只需要保证大树总是主树，小树总是在下方即可。此时只需要多一个数组sz，用于记录各树的大小，在合并前比较两棵树的大小即可
  
  
  

7. 路径压缩的加权quick-union算法

• find及union方法代码

    public int find(int p){        while(id[p]!=p){            id[p]=id[id[p]];//如果p不是根节点，就让他指向倒数第二级节点            p=id[p];//直接找到倒数第二级节点        }        return p;    }

• 思路：在find方法中添加一行代码，使得在寻找根节点的过程中，如果某个节点本身不是根节点，则让他指向上级节点的上级节点，隔层压缩。最终会使所有分支节点都将连接在根节点上
• 本质：使所有分支节点直接连接在根节点上，这样find方法最多只需要搜寻两层，而不需要搜寻lgN层。而union算法又可以与quick-union方法中的union方法般高效，进一步提升了计算效率。
  
  

8. 比较

id标号 id内容 特点 quick-find算法 触点标号 分量标号 find快，union慢 quick-union算法 触点标号 上级节点标号 单链表，find慢，union快 加权quick-union算法 触点标号 上级节点标号 避免瘦高树的生成，find提速 路径压缩的加权quick-union算法 触点标号 (不断变更的)上级节点编号 以常数级计算量置换更高效率