转载自百度百科:http://baike.baidu.com/view/521705.htm?fr=aladdin
目录
1定义编辑
2主要操作编辑
初始化
把每个点所在
集合初始化为其自身。
查找
查找元素所在的
集合,即根节点。
合并
将两个元素所在的
集合合并为一个集合。
通常来说,合并之前,应先判断两个元素是否属于同一
集合,这可用上面的“查找”操作实现。
3描述编辑
若某个
家族人员过于庞大,要判断两个是否是亲戚,确实还很不容易,给出某个亲戚关系图,求任意给出的两个人是否具有亲戚关系。 规定:x和y是亲戚,y和z是亲戚,那么x和z也是亲戚。如果x,y是亲戚,那么x的亲戚都是y的亲戚,y的亲戚也都是x的
亲戚。
4Input编辑
第一行:三个整数n,m,p,(n< =5000,m< =5000,p< =5000),分别表示有n个人,m个亲戚关系,询问p对亲戚关系。 以下m行:每行两个数Mi,Mj,1< =Mi,Mj< =N,表示Mi和Mj具有亲戚关系。 接下来p行:每行两个数Pi,Pj,询问Pi和Pj是否具有亲戚关系。
5Output编辑
P行,每行一个’Yes’或’No’。表示第i个询问的答案为“具有”或“不具有”亲戚关系。
问题实质
图0-0-1 {请补充图解}
比如判断3和4是否为亲戚时,我们检查3和4是否在同一个连通子图中,结果是在,于是他们是亲戚。又如7和10不在同一个连通子图中,所以他们不是亲戚。
用图的
数据结构的最大问题是,我们无法存下多至(M=)2 000 000条边的图,后面关于算法时效等诸多问题就免谈了。
我们可以给每个人建立一个
集合,集合的元素值有他自己,表示最开始时他不知道任何人是它的亲戚。以后每次给出一个亲戚关系a, b,则a和他的亲戚与b和他的亲戚就互为亲戚了,将a所在
集合与b所在集合合并。对于样例数据的操作全过程如下:
输入关系 分离
集合
初始状态
(2,4) {2,4}
(5,7) {2,4} {5,7}
(1,3) {1,3} {2,4} {5,7}
(8,9) {1,3} {2,4} {5,7} {8,9}
(1,2) {1,2,3,4} {5,7} {8,9}
(5,6) {1,2,3,4} {5,6,7} {8,9}
(2,3) {1,2,3,4} {5,6,7} {8,9}
算法需要以下几个子过程:
(1) 开始时,为每个人建立一个
集合SUB-Make-Set(x);
(2) 得到一个关系后a,b,合并相应
集合SUB-Union(a,b);
(3) 此外我们还需要判断两个人是否在同一个
集合中,这就涉及到如何标识集合的问题。我们可以在每个
集合中选一个代表标识集合,因此我们需要一个子过程给出每个集合的代表元SUB-Find-Set(a)。于是判断两个人是否在同一个
集合中,即两个人是否为亲戚,等价于判断SUB-Find-Set(a)=SUB-Find-Set(b)。
有了以上子过程的支持,我们就有如下算法。
PROBLEM-Relations(N, M, a1,…,aM, b1,…,bM, Q, c1,…,cQ, d1,…,dQ)
1 for i←1 to N
2 do SUB-Make-Set(i)
3 for i←1 to M
4 do if SUB-Find-Set(ai) != SUB-Find-Set(bi)
5 then SUB-Union(ai, bi)
6 for i←1 to Q
7 do if SUB-Find-Set(ci)=SUB-Find-Set(di)
8 then output “Yes?”
9 else output “No?”
解决问题的关键便为选择合适的
数据结构实现并查集的操作,使算法的实现效率最高。
单链表实现
一个节点对应一个人,在同一个
集合中的节点串成一条
链表就得到了
单链表的实现。在
集合中我们以
单链表的第一个节点作为集合的代表元。于是每个节点x(x也是人的编号)应包含这些信息:指向代表元即表首的指针head[x],指向表尾的指针tail[x],下一个节点的指针next[x]。
SUB-Make-Set(x)过程设计如下:
SUB-Make-Set(x)
10 head[x]←x
11 tail[x]←x
12 next[x]←NIL
求代表元的SUB-Find-Set(x)过程设计如下:
SUB-Find-Set(x)
13 return head[x]
图0-0-2
过程的伪代码如下:
SUB-Union(a,b)
14 next[tail[head[a]]]←head
15 tail[head[a]]←tail[head]
16 p←head
17 while p != NIL
18 do head[p]←head[a]
19 p←next[p]
我们来分析一下算法的时间效率。SUB-Make-Set(x)和SUB-Find-Set(x)都只需要O(1)的时间,而SUB-Union(a,b)的时间效率与b所在
链表的长度成线性关系。最坏情况下,即有操作序列SUB-Union(N-1,N), SUB-Union(N-2,N-1), …, SUB-Union(1,2)时,整个算法PROBLEM-Relations的
时间复杂度为O(N+M+N^2+Q)=O(N^2+M+Q)。
由于算法的
时间复杂度中O(M+Q)是必需的,因此我们要让算法更快,就要考虑如何使减小O(N^2)。
首先我们给出一个固定对象x的代表元指针head[x]被更新次数的
上界。由于每次x的代表元指针被更新时,x必然在较小的
集合中,因此x的代表元指针被更新一次后,集合至少含2个元素。类似地,下一次更新后,
集合至少含4个元素,继续下去,当x的代表元指针被更新 log k 次后,集合至少含k个元素,而集合最多含n个元素,所以x的代表元指针至多被更新 log n 次。所以M次SUB-Union(a,b)操作的
时间复杂度为O(NlogN+M)。算法总的
时间复杂度为O(NlogN+M+Q)。
并查集森林
图0-0-3
每个节点x包含这些信息:父节点指针p[x],树的深度rank[x]。其中rank[x]将用于启发式合并过程。
于是建立集合过程的
时间复杂度依然为O(1)。
SUB-Make-Set(x)
20 p[x]←x
21 rank[x]←0
SUB-Union(a,b)
22 SUB-Link(SUB-Find-Set(a),SUB-Find-Set(b))
SUB-Link(a,b)
23 p[a]←b
合并
集合的工作只是将a所在树的根节点的父节点改为b所在树的根节点。这个操作只需O(1)的时间。而SUB-Union(a,b)的时间效率决定于SUB-Find-Set(x)的快慢。
SUB-Find-Set(x)
24 if x=p[x]
25 then return x
26 else return SUB-Find-Set(p[x])
这个过程的时效与树的深度成线性关系,因此其平均
时间复杂度为O(logN),但在最坏情况下(树退化成
链表),时间复杂度为O(N)。于是PROBLEM-Relations最坏情况的
时间复杂度为O(N(M+Q))。有必要对算法进行优化。
第一个优化是启发式合并。在优化
单链表时,我们将较短的表链到较长的表尾,在这里我们可以用同样的方法,将深度较小的树指到深度较大的树的根上。这样可以防止树的退化,最坏情况不会出现。SUB-Find-Set(x)的
时间复杂度为O(log N),PROBLEM-Relations时间复杂度为O(N + logN (M+Q))。SUB-Link(a,b)作相应改动。
SUB-Link(a,b)
27 if rank[a]>rank
28 then p←a
29 else p[a]←b
30 if rank[a]=rank
31 then rank←rank+1
然而算法的耗时主要还是花在SUB-Find-Set(x)上。
第二个优化是路径压缩。它非常简单而有效。如图所示,在SUB-Find-Set(1)时,我们“顺便”将节点1, 2, 3的父节点全改为节点4,以后再调用SUB-Find-Set(1)时就只需O(1)的时间。
图0-0-4
于是SUB-Find-Set(x)的代码改为:
SUB-Find-Set(x)
32 if x≠p[x]
33 then p[x]←SUB-Find-Set(p[x])
34 return p[x]
该过程首先找到树的根,然后将路径上的所有节点的父节点改为这个根。实现时,递归的程序有许多栈的操作,改成非递归会更快些。
SUB-Find-Set(x)
35 r←x
36 while r≠p[r]
37 do r←p[r]
38 while x?r
39 do q←p[x]
40 p[x]←r
41 x←q
42 return r
改进后的算法
时间复杂度的分析十分复杂,如果完整的写出来足可写一节,这里我们只给出结论:改进后的PROBLEM-Relations其时间复杂度为O(N+(M+Q)*A(M+Q,N)),其中A(M+Q,N)为Ackerman函数的增长极为缓慢的逆函数。你不必了解与Ackerman函数相关的内容,只需知道在任何可想象得到的并查集
数据结构的应用中,A(M+Q,N)≤4,因此PROBLEM-Relations的
时间复杂度可认为是线性的O(N+M+Q)。
注意事项
本题的输入数据量很大,这使得我们的程序会在输入中花去不少时间。如果你用Pascal写程序,可以用库函数SetTextBuf为输入文件设置
缓冲区,这可以使输入过程加快不少。如果你是用C语言的话,就不必为此操心了,系统会自动分配
缓冲区。
6代码编辑
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
importjava.io.BufferedReader;
importjava.io.InputStreamReader;
importjava.io.StreamTokenizer;
publicclassMain{
privatestaticintfather[];
publicstaticvoidmain(String[]args)throwsException{
StreamTokenizerst=newStreamTokenizer(newBufferedReader(
newInputStreamReader(System.in)));
while
(st.nextToken()!=
StreamTokenizer.TT_EOF){
intn=(
int
)st.nval;
father=newint[n+1];
for
(inti=1;i<=n;i++){
father[i]=i;
}
st.nextToken();
intm=(
int
)st.nval;
st.nextToken();
intp=(
int
)st.nval;
for
(inti=0;i<m;i++){
st.nextToken();
inta=(
int
)st.nval;
st.nextToken();
intb=(
int
)st.nval;
union
(a,b);
}
for
(inti=0;i<p;i++){
st.nextToken();
inta=(
int
)st.nval;
st.nextToken();
intb=(
int
)st.nval;
a=findParent(a);
b=findParent(b);
System.out.println(a==b?
"Yes"
:
"No"
);
}
}
}
privatestaticvoidunion(intf,intt){
inta=findParent(f);
intb=findParent(t);
if
(a==b)
return
;
if
(a>b){
father[a]=b;
}
else
{
father[b]=a;
}
}
privatestaticintfindParent(intf){
while
(father[f]!=f){
f=father[f];
}
returnf;
}
}
|
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstdlib>
usingnamespacestd;
intfather[50002],a,b,m,n,p;
intfind(intx){
if
(father[x]!=x)
father[x]=find(father[x]);
/*
x代表例题中的人,father[x]中所存的数代表这一集合中所有人都与一个人有亲戚关系
相当于例题中第一个集合所有的元素都与第一个元素有亲戚关系
搜索时只要找元素所指向的father[x]=x的元素(即父元素)
然后比较两个元素的父元素是否相同就可以判断其关系
*/
returnfather[x];
}
intmain(){
inti;
scanf
(
"%d%d%d"
,&n,&m,&p);
for
(i=1;i<=n;i++)
father[i]=i;
for
(i=1;i<=m;i++){
scanf
(
"%d%d"
,&a,&b);
a=find(a);
b=find(b);
father[a]=b;
}
for
(i=1;i<=p;i++){
scanf
(
"%d%d"
,&a,&b);
a=find(a);
b=find(b);
if
(a==b)
printf
(
"Yes"
);
else
printf
(
"No"
);
}
return0;
}
|
pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
var
father:
array
[
1..5000
]oflongint;
i,j,k,p,n,m:
longint
;
functiongetfather(v:
longint
):
longint
;
begin
iffather[v]=vthenexit(v);
father[v]:=getfather(father[v]);
getfather:=father[v];
end
;
proceduremerge(x,y:
integer
);
begin
x:=getfather(x);
y:=getfather(y);
father[x]:=y;
end
;
functionjudge(x,y:
integer
):
boolean
;
begin
x:=getfather(x);
y:=getfather(y);
exit(x=y);
end
;
begin
readln(n,m,p);
fori:=1tondofather[i]:=i;
{预处理}
fori:=1tomdo
begin
read(j,k);
merge(j,k);
end
;
fori:=1topdo
begin
read(j,k);
ifjudge(j,k)thenwriteln(
'Yes'
)elsewriteln(
'No'
);
end
;
end
.
|