算法之路之并查集

欢迎关注作者个人博客www.peakhuang.com

并查集是一种用于解决动态连通性问题的数据模型

动态连通性

何为动态连通性(dynamic connectivity)

举个例子: 对于某个点，我们可以很轻易的判断它与周围的点是否有连通性，但当某个点与该点相距较远时，我们就很难判断是否存在着这样一条通路将这两个点连接起来

而利用并查集这种抽象的数据模型可以帮助我们快速解决类似的问题

并查集基本模型

我们可以利用数组去实现一个简单的并查集

在这个数组中，假设有n个点，将这n个点从0到n-1依次编号，数组的下标是它们的编号，而储存的内容是它们所连接的点，很容易的想到，当两个点对应的项的值相同时，这两个点在同一个集合中。

那么接下来如何实现连接和查找操作呢？

当两个点相连时，我们不妨让第一个点对应的项变为第二个点对应的项，同时遍历数组，让id值指向第一个点的值变为第二个点的值

public class UnionFind
{
    private int[] id;
    public UnionFind(int n)
    {
        id=new int[n];
        for(int i=0;i<n;i++)
        {
            id[i]=i;
		}
	}
    public void union(int x,int y)
    {
       int xid=id[x];
       int yid=id[y];
       for(int i=0;i<id.length;i++)
           if(id[i]==xid)id[i]=yid;
	}
    public boolean connected(int x,int y)
    {
      	return id[x]==id[y];
    }
}

对于这个算法而言，当n的数量级很大时，合并操作的开销是很大的

合并操作的优化

那么如何优化我们的合并操作呢，我们可以利用树状结构来连接

因为树是一个连通无回路的图，对于树中的点，都有一条与根节点相连的路径，所以我们将两个点的连接视为其中一点与另外一个点的根节点，更进一步，我们不妨直接让这两个点对应的树的根节点直接相连，达到合并的目的

代码修改如下：

public class UnionFind{
	private int[] id;
	 public UnionFind(int n)
    {
        id=new int[n];
        for(int i=0;i<n;i++)
        {
            id[i]=i;
		}
	}
	public int root(int x)
	{
		while(x!=id[x])
		{
			x=id[x];
		}
        return x;
	}
    public void union(int x,int y)
    {
       int i=root(x);
       int j=root(y);
       id[i]=j;
	}
    public boolean connected(int x,int y)
    {
      	return root(x)==root(y);
    }
}

但这样的代码对于大数量级仍有缺陷，合并操作可能制造出一个很高的树，从而使得寻根操作变得很慢

由于又提出一种优化

带权并查集

在合并操作时，由于可能出现很高的树，因此我们可以对每个节点带权，使得合并时小树永远在大树的下方

我们可以证明树的高度最高是$lo{g}_{2}n$

证明如下：每次合并时，若原树的高度增加，设原树的节点数为x，则添加树的节点数需大于x

当$x\ast 2\ast 2....\ast 2\ge n$时可知当x=1时，有树最大高度为$lo{g}_{2}n$

修改后的代码如下:

public class UnionFind{
	private int[] id;
    private int[] sz;
	 public UnionFind(int n)
    {
        id=new int[n];
        for(int i=0;i<n;i++)
        {
            id[i]=i;
            sz[i]=1;
		}
	}
	public int root(int x)
	{
		while(x!=id[x])
		{
			x=id[x];
		}
        return x;
	}
    public void union(int x,int y)
    {
       int i=root(x);
       int j=root(y);
       if(sz[i]>sz[j])
       {
           id[j]=i;
           sz[i]+=sz[j];
       }
       else
       {
           sz[j]+=sz[i];
           id[i]=j;
       }
	}
    public boolean connected(int x,int y)
    {
      	return root(x)==root(y);
    }
}

可以很清楚地看出带权并查集对树高有很大的改进

对于合并操作我们有了很大的改进，对于root搜索我们也可以有改进

路径压缩

在搜索的过程中，我们也可以将树的结构进行修改，使得树的高度尽量变小

路径压缩有两种方法

一种是递归压缩，使得所有的节点都连接到根节点上

private int root(int x)
{
    if(x!=id[x])
        id[x]=root(x);
    retrun x;
}

另一种是祖父压缩

private int root(int x)
{
    while(x!=id[x])
    {
    	id[x]=id[id[x]];
    	x=id[x];
	}
	return x;
}

从性能上来看第二种压缩方法更好，因为递归会开启更多的栈帧。

并查集的工业级代码

public class WeightedQuickUnionUF {
    private int[] parent;   // parent[i] = parent of i
    private int[] size;     // size[i] = number of elements in subtree rooted at i
    private int count;      // number of components 连通分支数

    /**
     * Initializes an empty union-find data structure with
     * {@code n} elements {@code 0} through {@code n-1}. 
     * Initially, each elements is in its own set.
     *
     * @param  n the number of elements
     * @throws IllegalArgumentException if {@code n < 0}
     */
    public WeightedQuickUnionUF(int n) {
        count = n;
        parent = new int[n];
        size = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
            size[i] = 1;
        }
    }

    /**
     * Returns the number of sets.
     *
     * @return the number of sets (between {@code 1} and {@code n})
     */
    public int count() {
        return count;
    }
  
    /**
     * Returns the canonical element of the set containing element {@code p}.
     *
     * @param  p an element
     * @return the canonical element of the set containing {@code p}
     * @throws IllegalArgumentException unless {@code 0 <= p < n}
     */
    public int find(int p) {
        validate(p);
        while (p != parent[p])
            p = parent[p];
        return p;
    }

    /**
     * Returns true if the two elements are in the same set.
     * 
     * @param  p one element
     * @param  q the other element
     * @return {@code true} if {@code p} and {@code q} are in the same set;
     *         {@code false} otherwise
     * @throws IllegalArgumentException unless
     *         both {@code 0 <= p < n} and {@code 0 <= q < n}
     * @deprecated Replace with two calls to {@link #find(int)}.
     */
    @Deprecated
    public boolean connected(int p, int q) {
        return find(p) == find(q);
    }

    // validate that p is a valid index
    private void validate(int p) {
        int n = parent.length;
        if (p < 0 || p >= n) {
            throw new IllegalArgumentException("index " + p + " is not between 0 and " + (n-1));  
        }
    }

    /**
     * Merges the set containing element {@code p} with the 
     * the set containing element {@code q}.
     *
     * @param  p one element
     * @param  q the other element
     * @throws IllegalArgumentException unless
     *         both {@code 0 <= p < n} and {@code 0 <= q < n}
     */
    public void union(int p, int q) {
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) return;

        // make smaller root point to larger one
        if (size[rootP] < size[rootQ]) {
            parent[rootP] = rootQ;
            size[rootQ] += size[rootP];
        }
        else {
            parent[rootQ] = rootP;
            size[rootP] += size[rootQ];
        }
        count--;
    }

参考资料：算法第四版