《算法》1.5union-find算法

1动态连通性

1.1提出问题

• 当程序从输入中读取了整数对p和q时，
• 如果从已知的所有整数对中都不能说明p和q是相连的，那么就将p和q相连接，并放到输出。
• 如果从已知的所有整数对中都可以说明p和q是相连的，那么就忽略p和q，继续处理下一对整数对。

1.2问题的应用

• 大型网络中链路的连接和通信问题
• 电子电路中的触点和电路问题
• 社交网络中的人的关系问题

1.3专用术语

• 将每一个数或者对象称为触点
• 将整数对称为连接
• 将等价类称为连通分量，简称分量

2实现

2.1抽象层的实现

/**
 * union-find的抽象类
 * @Author: AZhu
 * @Date: 2021/2/9 17:19
 */
public abstract class UF {

    int[] id; //分量id，以触点作为索引
    int count; //分量数量

    public UF(int N) {
        //初始化分量数组
        count = N;
        id = new int[N];
        for (int i = 0; i < N; i++) {
            id[i] = i;
        }
    }

    /**
     * 查找触点p所在分量的标识符
     * @param p 触点
     * @return 分量的标识符
     */
    public abstract int find(int p);

    /**
     * 在p和q之间添加一条连接
     * @param p 触点p
     * @param q 触点q
     */
    public abstract void union(int p, int q);

    /**
     * 获取连通分量的数量
     * @return 分量的数量
     */
    public int count() {
        return count;
    }

    /**
     * 如果p和q存在于同一个分量之中则返回true
     * @param p 触点p
     * @param q 触点q
     * @return 是否存在于同一个分量之中
     */
    public boolean connected(int p,int q) {
        return find(p) == find(q);
    }

}

2.2QuickFind算法实现

/**
 * UF的QuickFind实现
 * @Author: AZhu
 * @Date: 2021/2/9 17:45
 */
public class QuickFindUF extends UF {

    public QuickFindUF(int N) {
        //调用父类的构造器
        super(N);
    }

    @Override
    public int find(int p) {
        return id[p];
    }

    @Override
    public void union(int p, int q) {
        int pId = find(p);
        int qId = find(q);
        if (pId == qId) {
            return;
        }
        //将p所在分量的所有触点 重命名 为q所在的分量名
        for (int i = 0; i < id.length; i++) {
            if (id[i] == pId) {
                id[i] = qId;
            }
        }
        count--;
    }
}

QuickFind算法分析：

• 每次find()调用只需要访问数组一次
• 归并两个分量的union()操作访问数组的次数在(N+3)到(2N+1)之间。

由于我们使用QuickFind算法来解决动态连通性问题并且最后只得到了一个连通分量。

因此至少调用N-1次union()，所以至少访问数组(N+3)(N-1) ~ N^2次。

2.3QuickUnion算法实现

/**
 * UF的QuickUnion实现
 * @Author: AZhu
 * @Date: 2021/2/9 18:08
 */
public class QuickUnionUF extends UF {

    public QuickUnionUF(int N) {
        //调用父类的构造器
        super(N);
    }

    @Override
    public int find(int p) {
        //逐层深入，找出根结点
        while (p != id[p]) {
            p = id[p];
        }
        return p;
    }

    @Override
    public void union(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        if (pRoot == qRoot) {
            return;
        }
        //合并两棵树
        id[pRoot] = qRoot;
        count--;
    }
}

QuickUnion算法分析：

QuickUnion算法中的find()方法访问数组的次数为1加上给定触点所对应的节点中的深度的两倍。

union()和connected()访问数组的次数为两次find()操作（如果union()中给定的两个触点分别存在于不同的树种则还需要加1）。

在最坏的情况下，处理N对整数所需的所有find()操作访问数组的总次数为3+5+7+...+(2N-1) ~ N^2。

2.4加权QuickUnion算法实现

/**
 * @Author: AZhu
 * @Date: 2021/2/9 18:17
 */
public class WeightedQuickUnionUF extends QuickUnionUF {

    private int[] sz; //（由触点作为索引的）各个根结点所对应的分量的大小。用作记录每棵树的大小

    public WeightedQuickUnionUF(int N) {
        //调用父类的构造器
        super(N);
        sz = new int[N];
        for (int i = 0; i < N; i++) {
            sz[i] = 1;
        }
    }

    @Override
    public void union(int p, int q) {
        int i = find(p);
        int j = find(q);
        if (i == j) {
            return;
        }
        //将小树的根结点连接到大树的根结点上
        if (sz[i] < sz[j]) {
            id[i] = j;
            sz[j] += sz[i];
        } else {
            id[j] = i;
            sz[i] += sz[j];
        }
        count--;
    }
}

加权QuickUnion算法分析：

对于N个触点，加权QuickUnion算法构造的森林中的任意结点的深度最多为lgN。

加权QuickUnion算法处理N个触点和M条连接时最多访问数组cMlgN次，其中c为常数。

3展望

研究各种基本问题是所遵循的基本步骤：

1. 完整而详细地定义问题，找出解决问题所必须的基本抽象操作，定义一份API
2. 简洁地实现一种初级算法，给出一个精心组织的开发用例并使用实际数据作为输入。
3. 当实现所能解决的问题的最大规模达不到期望时决定改进还是放弃。
4. 逐步改进实现，通过经验性分析或数学分析验证改进后的效果。
5. 用更高层次的抽象表示数据结构或算法来设计更高级的改进版本。
6. 如果可能尽量为最坏情况下的性能提供保证，但在处理普通数据时也要保证有良好的性能。
7. 在适当的时候将更细致的深入研究留给有经验的研究者并继续解决下一个问题。