Union-Find
问题描述:
给定一个n个序列的对象,有两种操作:
-Union command:连接两个对象;
-Find/connected query:两个对象是否连接(有路径)
算法实现方式
1.用一个数组保存着每个对象所在的connected component,这种方式可以快速进行FIND,但是在union操作时需要遍历整个对象数组
2.利用树的观点,在数组中保存每个对象节点的parent,这个每个connected component就是一棵树,这种方式union很高效,只需要更新相应节点的parent即可,但是在find的时候可能就会遍历整个树,特别是当一棵树比较高的时候。
3.在上述2中实现union(p,q)的时候,我们用一种特定的方式将p所在的树的置为q所在树的孩子,没有考虑到树的大小,就会导致严重失衡的情况。Weighted quick-union 引入一个新的数组来保存每棵树的尺寸,总是将小树链入到大树下,实现相对的平衡。
4.利用path compression进一步对上述算法进行优化,在每一次root操作的时候,不单单只是追溯查询一个节点的根,而是动态的将其根节点往上推进。从而使得 component tree 越来越平坦化。 如下要查询节点6的根节点,在查询的最后会更新6直接指向根节点。
接下来会把3,1分别指针指向root
具体代码
--------1
//这种方式可以快速判断是否相连,但是union操作需要遍历整个对象数组
public
class
QuickFindUF {
// 这个数组保存着这个N个节点的所在分组
private
int
[]
id
;
public
QuickFindUF(
int
n) {
id
=
new
int
[n];
for
(
int
i = 0; i < n; i ++) {
id
[ i] = i ;
}
}
public
boolean
find(
int
p,
int
q) {
return
id
[p] ==
id
[q];
}
// 连接p,q节点的时候,要将p所在component中的所有节点的id更新
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;
}
}
}
-----------2
//这种方式可以快速实现俩个
public
class
QuickUnionUF {
// 这个数组保存着该对象的parent
private
int
[]
id
;
public
QuickUnionUF(
int
n) {
id
=
new
int
[n];
for
(
int
i = 0; i < n; i++) {
id
[i] = i;
}
}
// 辅助函数,追溯节点的n的根
private
int
root(
int
n) {
while
(n !=
id
[n])
n =
id
[n];
return
n;
}
public
boolean
find(
int
p,
int
q) {
return
root(p) == root(q);
}
// 连接p,q节点的时候,要将p的parent的parent更新为q的parent
public
void
union(
int
p,
int
q) {
int
parentp =
id
[p];
int
parentq =
id
[q];
id
[parentp] = parentq;
}
}
---------------3
public
class
WeightedQuickUnionUF {
private
int
[]
id
;
// id[i] = parent of i
private
int
[]
sz
;
// sz[i] = number of objs in subtree rooted at i
private
int
count
;
// num of components
public
WeightedQuickUnionUF(
int
N) {
count
= N;
id
=
new
int
[N];
sz
=
new
int
[N];
for
(
int
i = 0; i < N; i++) {
id
[i] = i;
sz
[i] = 1;
}
}
public
int
count() {
return
count
;
}
// 得到包含这个对象的component的ID,也就是根节点
public
int
root(
int
p) {
while
(p !=
id
[p])
p =
id
[p];
return
p;
}
public
boolean
connected(
int
p,
int
q) {
return
root(p) == root(q);
}
// 合并包含p,q的两个components,会考虑树的大小
public
void
union(
int
p,
int
q) {
int
rootP = root(p);
int
rootQ = root(q);
if
(rootP == rootQ)
return
;
if
(
sz
[rootP] <
sz
[rootQ]) {
id
[rootP] = rootQ;
sz
[rootQ] +=
sz
[rootP];
}
else
{
id
[rootQ] = rootP;
sz
[rootP] +=
sz
[rootQ];
}
}
}
----------------4
public
class
WeightedQuickUnionWitchPathCompression {
private
int
[]
id
;
// id[i] = parent of i
private
int
[]
sz
;
// sz[i] = number of objs in subtree rooted at i
private
int
count
;
// num of components
public
WeightedQuickUnionWitchPathCompression(
int
N) {
count
= N;
id
=
new
int
[N];
sz
=
new
int
[N];
for
(
int
i = 0; i < N; i++) {
id
[i] = i;
sz
[i] = 1;
}
}
public
int
count() {
return
count
;
}
// path compression实现在这里。
public
int
root(
int
p) {
int
root = p;
while
(root !=
id
[root])
root =
id
[root];
// 会将p以上的节点全部指向root
while
(p != root) {
int
newp =
id
[p];
id
[p] = root;
p = newp;
}
return
root;
}
public
boolean
connected(
int
p,
int
q) {
return
root(p) == root(q);
}
// 合并包含p,q的两个components,会考虑树的大小
public
void
union(
int
p,
int
q) {
int
rootP = root(p);
int
rootQ = root(q);
if
(rootP == rootQ)
return
;
if
(
sz
[rootP ] <
sz
[rootQ]) {
id
[ rootP] = rootQ;
sz
[rootQ] +=
sz
[ rootP];
}
else
{
id
[rootQ] = rootP;
sz
[ rootP] +=
sz
[rootQ];
}
}
}
备注:参考普林斯顿大学《算法,part I》