union-find（并查集）算法
背景:
union-find算法是用来解决动态连通性问题的。
动态连通性问题的数学表达:
问题的输入是一列整数对。一个整数对可以被理解成这个整数对的两个整数相连。
eg：我们输入整数对 p,q，那么"p和q是相连的"。
相连:我们假设相连是一种对等的关系，就意味着它有
自反性:p和p是相连的
对称性:如果p和q相连，那么q和p也是相连的
传递性:如果p和q是相连的，q和r是相连的，那么p和r而是相连的
问题:我们已知一些整数对(即所有点的相连关系)，那么如何得知某两个点是否相连?
现实中的例子:
-
大型网络中的计算机
是否其中的两台已经相互连接,还是需要架设新的连接来进行通讯?
-
社交网络中的人
两个人之间是否有潜在的朋友关系？
-
电路中的触点
两个触点是否彼此连通？
问题的解决
编程背景
变量名的等价性:在某些编程环境中允许两个等价的变量名(指向同一个对象的多个引用)。在声明后，系统需要能判别两个变量名是否等价。（如FORTRAN语言）推动了如下我们要讲到的算法的发展。
数学思考
从数学上的抽象讲，在处理一个输入的整数对p,q时，我们判断它们是否已经属于同一个集合，如果是则忽略，如果不是，我们将p所属的集合和q所属的集合归并成一个集合。
* 术语
对象(一个整数):触点
整数对: 连接
等价类:分量或连通分量
那么我们可以用0到N-1个整数表示N个触点
union-find 算法 API
| public class | UF | |
|---|---|---|
| UF(int N) | 用整数标识初始化N个触点 | |
| void | union(int p,int q) | 在p和q中间添加一条连接 |
| int | find（int p） | p所在分量的标识符（0到N-1） |
| boolean | connected(int p,int q) | 如果p和q在同一个分量中则返回true |
| int | count() | 连通分量的数量 |
从而：我们的任务转化为了实现此API即可。
实现此API:
1.定义一种数据结构表示已知的连接
API已经说明触点和分量都可以用int表示，所以我们可以使用id[]
2.基于此数据结构实现高效的union(),find(),connected()和count()方法
public class UF(){
public int id[];
public int count;
public void UF(int N){
id =new int[N];
count=N;
for(int i=0;i<N;i++){
id[i]=i;
}
}
public boolean connected(int p,int q){
return find(p)==find(q0);
}
public int count(){
return count;
}
public int find(int p)
public void union(int p,int q)
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))
{
uf.union(p,q);
StdOut.println(p+""+q);
}
}
StdOut.println(uf.count()+"components");
}
}
至此，我们只需要实现核心的union和find方法即可。
union-find 的成本模型
在研究union-find算法时，我们统计的是数组的访问次数。
union,find 方法实现
quick-find算法
public int find（int q）
{
return id[q];}
public void union(int p, int q){
int pID=id[p];
int qID=id[q];
if(pID=qID) return;
for(int i=0;i<N;i++){
if(id[i]=pID) id[i]=qID;
}
count--;
}
复杂度计算:在union之前，使用了connect(从而调用了find()两次，进行两次数组访问),union中使用了find()两次，改变数组进行数组(访问数组N次)，改变值(1至(N-1))个。所以每调用一次union访问了((N+3)至(2N+1))次数组假设最后剩余一个连通分量，那么至少union访问了数组(N+3)(N-1)次~N2次。所以在N变大时效率较低
quick-union算法
这里我们使用一种加快union的算法，同时find变得复杂。
我们使用同样的数据结构id[]。索引代表触点，但值代表着和它是同一分量的其他触点。即形成树结构,union时只需把根节点的值改变。
public void union(int p, int q){
int rootq=find(q);
int rootp=find(p);
id[rootq]=id[rootp];
count--;
}
public int find(int p){
while(id[p]!=p){
p=id[p];
}
return p;
}
复杂度计算
find()需要访问的数组次数:1到2N，当最后的分量是1的时候,运行了union()方法N次。
即最好情况是线性复杂度，最坏时候是平方复杂度。可以看做是quick-find算法的一种改进。
再对此方法进行改进
加权quick-union算法
我们的树高度是不平均的,才导致了从N~N2的效率。
改进代码使树的高度变小来实现lgN的复杂度
代码如下
public class UF(){
public int id[];
public int size[]; //新加入的代码，表示每个分量的节点数
public int count;
public void UF(int N){
id =new int[N];
count=N;
for(int i=0;i<N;i++){
id[i]=i;
}
size =new int[N];
for(int i=0;i<N;i++){
size[i]=1;
}
}
public boolean connected(int p,int q){
return find(p)==find(q);
}
public int count(){
return count;
}
public void union(int p, int q){
int rootq=find(q);
int rootp=find(p);
if(rootq<rootp){
//每次将把小树放到大树上以减小树高以提高find()的效率(logN)
id[rootq]=id[rootp];
size[rootq]+=size[rootp];}
else{
id[rootp]=id[rootq];
size[rootp]+=size[rootq];}
count--;
}
public int find(int p){
while(id[p]!=p){
p=id[p];
}
return p;
}
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))
{
uf.union(p,q);
StdOut.println(p+""+q);
}
}
StdOut.println(uf.count()+"components");
}
}
最优算法:路径压缩的加权quick-union算法
即在find()中加入一个循环，使得树扁平化，然而也并非所有时候都可以保证时间是线性的。
public int find(int p){
int a=p;
while(id[p]!=p){
p=id[p];
}
while(id[a]!=p){
//新加入的循环，把每个在这条路径的节点都移动到根节点
a=id[a];
id[a]=p;
}
return p;
}
带来的思考
我们解决问题的时候
- 完整详细地定义问题，找出解决问题所需要的基本抽象操作并定义API
- 间接地实现初级算法，并使用开发用例
- 在实现所解决的问题最大规模达不到期望时候改进或放弃
- 逐步改进，进行经验性分析和数学分析
- 用更高层次的抽象表示数据结构和算法
- 最坏事后和处理普通数据都要有良好性能(如果可能)
- 可以将更深入的研究留给更有经验的研究者
引用：Sedgewick, R. (2003). Algorithmen. München: Addison-Wesley.