动态连通性（Dynamic Connectivity）

01_dynamic-connectivity 动态连通性_哔哩哔哩_bilibili

01_dynamic-connectivity 动态连通性是普林斯顿大学丨算法第四版 Princeton University 丨 Algorithms Part 1的第2集视频，该合集共计59集，视频收藏或关注UP主，及时了解更多相关视频内容。

https://www.bilibili.com/video/BV1Jt411P77c?p=2

什么是并查集？

建立模型

1. 我们可以把连通的节点放入到同一个集合中。

2. 当我门连接两个不连通的节点时，就将这两个节点所在的集合合并成一个集合。

3. 当查询两个节点是否连通的时候，只用判断这两个节点是否在一个集合中即可。

public interface IDynamicConnectivity {
    void union(int p,int q);
    boolean connected(int p,int q);
}

Quick-Find 快速查询

public class QuickFind implements IDynamicConnectivity {
	private int[] id;
	public QuickFind(int size) {
    id = new int[size];
    for (int i = 0; i < id.length; i++) {
        id[i] = i;
    }
	}
}

tips: 其实这里等式的右边半只要不重复皆可，它就是集合的唯一标识，不一定需要等于 i，如果你喜欢 id[i] = i + 114514 都是可以的。

@Override
public boolean connected(int p, int q) {
    return id[p] == id[q];
}

@Override
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;
        }
    }
}

tips: 这里很容易犯一个错，那就是 id[i] == pid 这里，有人可能会写成 id[i] == id[p] ，这显然是错误的。因为过程中会修改到 id[p] = qid 那么 id[p] 之后的节点就变成判断 id[i] == qid。

复杂度分析

总结

public class QuickFind implements IDynamicConnectivity{
    private int[] id;
    public QuickFind(int size) {
        id = new int[size];
        for (int i = 0; i < id.length; i++) {
            id[i] = i;
        }
    }

    @Override
		// On的查找时间
		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;
            }
        }
    }

    @Override
		// O1的比较时间
		public boolean connected(int p, int q) {
        return id[p] == id[q];
    }
}

Quick-Union

@Override
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;
        }
    }
}

把他们挂在树上

把树捋顺了！！

public class TreeNode {
		int value;
		TreeNode left;
		TreeNode right;
}

public class TreeNode {
		int value;
		TreeNode father;
}

public QuickUnion(int size) {
    id = new int[size];
    for (int i = 0; i < id.length; i++) {
        id[i] = i;
    }
}

tips: 与 Quick-Find 不同，这里 id[i] 不再是单纯的标记，他需要承接节点的关系。

• Find：当连通的节点都存储在一个树上，那么判断他们是否连通只需要判断他们的根节点是否为同一个。

• Union：当我们要连通两个节点的时候，需要找寻到他们的根节点，并让某一个根节点成为另一个根节点的叶子结点。

private int findRoot(int p) {
    while (p != id[p]) {
        p = id[p];
    }
    return p;
}

@Override
public boolean connected(int p, int q) {
    return findRoot(p) == findRoot(q);
}

@Override
public void union(int p, int q) {
    int proot = findRoot(p);
    int qroot = findRoot(q);
    id[proot] = qroot;
}

复杂度分析

On 是怎么诞生的？我们现在有 5 个节点，那么当我们union(0,1)的时候他会形成一个2层的树，但我们继续 union(0,2) 的时候就会形成一个3层的树，依次类推，N 个节点最终会形成一个 N 层的树，此时树退化成了链表。

 

总结

public class QuickUnion implements IDynamicConnectivity{

		private int[] id;
		public QuickUnion(int size) {
		    id = new int[size];
		    for (int i = 0; i < id.length; i++) {
		        id[i] = i;
		    }
		}
		
		@Override
		public void union(int p, int q) {
		    int proot = findRoot(p);
		    int qroot = findRoot(q);
		    id[proot] = qroot;
		}
		
		@Override
		public boolean connected(int p, int q) {
		    return findRoot(p) == findRoot(q);
		}
		
		// 最坏 On 的查找时间
		private int findRoot(int p) {
		    while (p != id[p]) {
				    p = id[p];
		    }
		    return p;
    }
}

Weighted Quick-Union

干掉On

枝繁叶茂

public class WeightedQuickUnion implements IDynamicConnectivity {
    private int[] id;
    private int[] sz;
    public WeightedQuickUnion(int size) {
        id = new int[size];
        sz = new int[size];
        for (int i = 0; i < id.length; i++) {
            id[i] = i;
            sz[i] = 1;
        }
    }
}

@Override
public void union(int p, int q) {
    int proot = findRoot(p);
    int qroot = findRoot(q);
    if (sz[proot] < sz[qroot]) {
        id[proot] = qroot;
        sz[qroot] += sz[proot];
    } else {
        id[qroot] = proot;
        sz[proot] += sz[qroot];
    }
}

@Override
public boolean connected(int p, int q) {
    return findRoot(p) == findRoot(q);
}

private int findRoot(int p) {
    while (p != id[p]) {
		    p = id[p];
    }
    return p;
}

复杂度分析

路径压缩

private int findRoot(int p) {
    while (p != id[p]) {
				//路径压缩，节点的父节点，变成祖父节点相当于减少了一层。
				id[p] = id[id[p]];
        p = id[p];
    }
    return p;
}

总结

public class WeightedQuickUnion implements IDynamicConnectivity{

    private int[] id;
    private int[] sz;
    public WeightedQuickUnion(int size) {
        id = new int[size];
        sz = new int[size];
        for (int i = 0; i < id.length; i++) {
            id[i] = i;
            sz[i] = 1;
        }
    }

		//每次合并选择深度最小的那个节点合并
		//什么情况下树的深度会加1？当两个节点节点数量一样大的时候深度就会+1
    //此时节点数量翻倍，所以我们假设一个节点最多可以翻x倍
		//得到 2^x = N所以树最大深度是 lgN
		@Override
    public void union(int p, int q) {
        int proot = findRoot(p);
        int qroot = findRoot(q);
        if (sz[proot] < sz[qroot]) {
            id[proot] = qroot;
            sz[qroot] += sz[proot];
        } else {
            id[qroot] = proot;
            sz[proot] += sz[qroot];
        }
    }

    @Override
    public boolean connected(int p, int q) {
        return findRoot(p) == findRoot(q);
    }

		//由于 union保证了树深 lgN所以 findRoot最差情况是 lgN
		private int findRoot(int p) {
        while (p != id[p]) {
						//路径压缩，节点的父节点，变成祖父节点相当于减少了一层。
						id[p] = id[id[p]];
            p = id[p];
        }
        return p;
    }
}