Union-find
终于抽出时间总结回顾一下Union-find了!
《算法》书中,从quick_find,quick_union到weighted_quick_union到path compression,一步步深入。下面是用C++实现的版本。
quick find
O(1)时间查找一个节点所属的组,平均用O(n)时间合并两个节点。思路是这样的:将N个点所属的组(id)初始为相应的标号:0~N-1。之后,若碰到合并两个节点时,则将每个组内的所有点的id更新为同一个值。
#include <vector>
#include <time.h>
#include <fstream>
using namespace std;
/*
O(1)查找两个节点是否连通,O(n)时间Union
相当于给每个节点进行分组,每个组内节点的标号是一致的
*/
class QuickFindUF
{
public:
QuickFindUF(int N);
int get_count();
int find(int p);
bool connected(int p, int q);
void Union(int p, int q);
private:
vector<int> id;
int count; //连通分量数
};
QuickFindUF::QuickFindUF(int N)
{
count = N;
id = vector<int>(N);
for (int i = 0; i < N; i++)
{
id[i] = i;
}
}
int QuickFindUF::get_count()
{
return count;
}
int QuickFindUF::find(int p)
{
return id[p];
}
bool QuickFindUF::connected(int p, int q)
{
return find(p) == find(q);
}
void QuickFindUF::Union(int p, int q)
{
int pID = find(p);
int qID = find(q);
//先检查是否连通。所以当需要连接两个点时,不需要在外面检测是否连通
if (pID == qID)
return;
int sz = id.size();
for (int i = 0; i < sz; i++)
{
if (find(i) == pID)
id[i] = qID;
}
count--;
}
//0.01s
int main()
{
ifstream cin("mediumUF.txt");
ofstream cout("outmediumUF.txt");
int N;
cin >> N;
QuickFindUF qfUF(N);
clock_t start, end;
start = clock();
while (cin)
{
int p, q;
cin >> p >> q;
if (qfUF.connected(p, q)) continue;
qfUF.Union(p,q);
}
end = clock();
double totoal_time = (double)(end-start)/CLK_TCK;
cout << qfUF.get_count() << endl;
cout << "quick find total time: " << totoal_time << "s";
cin.close();
cout.close();
}
quick union
quick union为了提高union的速度,改变了union策略。对于每个点而言,存放它的父结点。初始时,每个点的父节点是本身。当合并两个节点的时候,先找出这个点的祖先节点rootP,rootQ,若两者不等,则将rootP的父节点设置成rootQ。所以,parent数组里保存的是每个点的父节点,而当一个节点的父节点是自身的时候,那么这个节点即是根节点。对于查找一个节点的父节点,时间复杂度为树的高度;而union两个节点的复杂度也是树的高度,因为union的时候,需要先找出p,q两个节点的根节点。union之后,原来以rootP为根结点的树直接挂到rootQ上,因此所有节点的高度加1。
#include <vector>
#include <fstream>
#include <time.h>
using namespace std;
/*
parent[]数组用父链接的形式组成了一个森林。
*/
class QuickUnionUF
{
public:
QuickUnionUF(int N);
int get_count();
int find(int p);
bool connected(int p, int q);
void Union(int p, int q);
private:
vector<int> parent;
int count;
};
QuickUnionUF::QuickUnionUF(int N)
{
parent = vector<int>(N);
count = N;
for (int i = 0; i < N; i++)
{
parent[i] = i;
}
}
int QuickUnionUF::get_count()
{
return count;
}
int QuickUnionUF::find(int p)
{
while (p != parent[p])
{
p = parent[p];
}
return p;
}
bool QuickUnionUF::connected(int p, int q)
{
return find(p) == find(q);
}
void QuickUnionUF::Union(int p, int q)
{
int rootP = find(p);
int rootQ = find(q);
if (rootP == rootQ)
return;
parent[rootP] = rootQ; //以rootP为根的树的高度加1.
count--;
}
//0.051s
int main()
{
ifstream cin("mediumUF.txt");
ofstream cout("outmediumUF.txt");
int N;
cin >> N;
QuickUnionUF quUF(N);
clock_t start, end;
start = clock();
while (cin)
{
int p, q;
cin >> p >> q;
if (quUF.connected(p, q)) continue;
quUF.Union(p,q);
}
end = clock();
double totoal_time = (double)(end-start)/CLK_TCK;
cout << quUF.get_count() << endl;
cout << "quick union total time: " << totoal_time << "s";
cin.close();
cout.close();
}
weighted quick union
quick union算法有一点不好的是,parent数组表示的树可能非常不平衡。因此提出一种改进的算法。改进的地方在于:每次union的时候,不是盲目地直接将rootP的父节点设置成rootQ,而是根据两棵树的大小:树小的连接到树大的根结点上。这样,树就会一直保持平衡。要实现这一点,要添加一个变量来保持树的大小。
#include <vector>
#include <iostream>
#include <fstream>
#include <time.h>
using namespace std;
/*
使得树更平衡,查找次数减少
*/
class WeightedQuickUnion
{
public:
WeightedQuickUnion(int N);
int get_count();
int find(int p);
bool connected(int p, int q);
void Union(int p, int q);
private:
vector<int> parent;
vector<int> size;
int count;
};
WeightedQuickUnion::WeightedQuickUnion(int N)
{
parent = vector<int>(N);
size = vector<int>(N);
count = N;
for (int i = 0; i < N; i++)
{
parent[i] = i;
size[i] = 1;
}
}
int WeightedQuickUnion::get_count()
{
return count;
}
int WeightedQuickUnion::find(int p)
{
while (p != parent[p])
{
parent[p] = parent[parent[p]]; //path compression
p = parent[p];
}
return p;
}
bool WeightedQuickUnion::connected(int p, int q)
{
return find(p) == find(q);
}
void WeightedQuickUnion::Union(int p, int q)
{
int rootP = find(p);
int rootQ = find(q);
if (rootP == rootQ) //必须加上。如果p,q本来相连,后面的代码不能执行.
return;
if (size[rootP] < size[rootQ])
{
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
}
else
{
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
}
count--;
}
path compression
实现了树的平衡还没完,还可以在查找一个节点的根结点的过程中,进一步减小树的深度。即把树flatten。理想情况下,只有一个根结点,所有的孩子在高度为1的地方,这样find起来就会比较快。可以用two-pass来完成,即找到p的根结点后,把路径上的点的根结点都设为根结点。
但是我们最后采用了一个简便的方法:如果一个节点p的父节点parent[p] != p,即p不是根结点,那么就把p的父节点设置成p的爷爷节点。只需要在find的while循环中加一行代码就可以实现了。代码见weighted quick union代码中注释为//path compression
的地方。达到的效果是把树的高度减半。