并查集详解

并查集的概念

并查集顾名思义就是合并和查找，问题在于合并什么，查找什么。这里有一种朴素的思想来解释这两个问题。就是把这个想成一棵树。合并什么？就是把不在这棵树里的节点合并到该树中，而查找的是该棵树的根节点。大家可以想象有一棵树，如下： 
 
从上面可以看出并查集的特点，连通和分类。因此，并查集在算法中的运用很灵活也很广泛，比如朋友圈算法(朋友的朋友是朋友)，团伙问题(朋友的朋友是朋友，敌人的敌人是朋友)，连通图，最近公共祖先等等。下面将对几种典型的算法进行讲解。

朋友圈

题目描述：

假如已知有n个人和m对好友关系（存于数字r）。如果两个人是直接或间接的好友（好友的好友的好友...），则认为他们属于同一个朋友圈，请写程序求出这n个人里一共有多少个朋友圈。

输入

输入包含多个测试用例，每个测试用例的第一行包含两个正整数 n、m，1=<n，m<=100000。接下来有m行，每行分别输入两个人的编号f，t（1=<f，t<=n），表示f和t是好友。 当n为0时，输入结束，该用例不被处理。对应每个测试用例，输出在这n个人里一共有多少个朋友圈。

样例输入 
5 3 
1 2 
2 3 
4 5 
3 3 
1 2 
1 3 
2 3 
0 
样例输出： 
2 
1 
来源： 
小米2013年校园招聘笔试题

思路 
这题是基本并查集概念的运用。从题中可以看出，关系组只有两种，一种是朋友，一种是陌生人。说白了，这就是用并查集来分类。同一棵树中就是同一个朋友圈，分居两棵树，就是不同的两个朋友圈。代码如下：

import java.util.Scanner;public class Main{    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int N;        while((N = sc.nextInt())!=0){            int M = sc.nextInt();            int root[] = new int[N+1];            for(int i=1;i<N+1;i++){//初始化根节点为自己，即各个自为一棵只有一个节点的树                root[i]=i;            }            while(M-->0){                int x = sc.nextInt();                int y = sc.nextInt();                    union(root,x,y);//合并两棵树            }            int sum = 0;            for(int i=1;i<N+1;i++){                if(root[i]==i){//根节点为自己，表示是当前朋友圈的根节点，如果不是，则表示该节点属于某个根节点的朋友圈                    sum++;                }            }            System.out.println(sum);        }    }        //合并的过程    private static void union(int[] root, int x, int y) {        int rootx = find(root,x);//递推寻找根节点        int rooty = find(root,y);        if(rootx==rooty){//如果根节点不等，说明两节点不在同一棵树中            return;        }        root[rootx]=rooty;//将x节点所在的树合并到y所在的树中（注：谁合并谁都无所谓）    }       //查找合并过程    private static int find(int[] root, int x) {        if(root[x]!=x){//如果没找到根节点就继续往上找，找到根节点之后返回，并沿路修改每个节点的根节点            root[x]=find(root,root[x]);        }        return root[x];    }}
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
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

团伙问题

题目描述 
整个组织有n个人，任何两个认识的人不是朋友就是敌人，而且满足：①我朋友的朋友是我的朋友；②我敌人的敌人是我的朋友。所有是朋友的人组成一个团伙。现在，警方委派你协助调查，拥有关于这n个人的m条信息（即某两个人是朋友，或某两个人是敌人），请你计算出这个城市最多可能有多少个团伙。 数据范围：2≤N≤1000，1≤M≤1000。

输入数据： 
第一行包含一个整数N，第二行包含一个整数M，接下来M行描述M条信息，内容为以下两者之一：“x y 1”表示x与y是朋友；“x y 0”表示x与y是敌人（1≤x≤y≤N）。 0为输入结束。 
输出数据：包含一个整数，即可能的最大团伙数。

样例输入： 
6 4 
1 4 1 
3 5 1 
4 6 0 
1 2 0 
0

样例输出： 
3

思路 
该题是上面朋友圈的升级版，唯一不同就是多了一种关系–敌人，所以一共有三种关系：朋友，敌人，陌生人。该题解题的关键点在于要能明白：x的敌人y与x之前的敌人是一个朋友圈，y的敌人与x是朋友。假设e[]表示敌人朋友圈，则e[x]与y是同一个朋友圈，或者说e[y]与x是同一个朋友圈，因此便转换为朋友圈问题。这个一点能明白，解题就很容易了。代码如下：

import java.util.Scanner;public class Main{    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int N;        while((N = sc.nextInt())!=0){            int M = sc.nextInt();            int root[] = new int[N+1];            int e[] = new int[N+1];//存放敌人            for(int i=1;i<N+1;i++){                root[i]=i;//根节点为自身                e[i]=0;//初始化，每个人都没有敌人            }            while(M-->0){                int x = sc.nextInt();                int y = sc.nextInt();                int type = sc.nextInt();                if(type==1){//如果是朋友，则合并朋友圈                   union(root,x,y);                }else{//如果是敌人                    if(e[x]==0){//如果没有敌人，则该次关系的敌人就是第一个敌人                        e[x]=y;                    }else{                        union(root,e[x],y);//如果已存在敌人，则去合并敌人朋友圈                    }                    if(e[y]==0){//相互记录                        e[y]=x;                    }else{                        union(root,e[y],x);                    }                }            }            int sum = 0;            for(int i=1;i<N+1;i++){                if(root[i]==i){                    sum++;                }            }            System.out.println(sum);        }    }    //合并朋友圈(敌人朋友圈)    private static void union(int[] root, int x, int y) {        int rootx = find(root,x);        int rooty = find(root,y);        if(rootx==rooty){            return;        }        root[rootx]=rooty;    }    //查找根节点    private static int find(int[] root, int x) {        if(root[x]!=x){            root[x]=find(root,root[x]);        }        return root[x];    }}
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
56
57
58
59
60
61
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
56
57
58
59
60
61

连通图

题目描述： 
现在有孤岛n个，孤岛从1开始标序一直到n，有道路m条（道路是双向的，如果有多条道路连通岛屿i，j则选择最短的那条），请你求出能够让所有孤岛都连通的最小道路总长度。

输入： 
数据有多组输入。 
每组第一行输入n(1<=n<=1000),m(0<=m<=10000)。

输出： 
对每组输入输出一行，如果能连通，输出能连通所有岛屿的最小道路长度，否则请输出字符串”no”。

样例输入： 
3 5 
1 2 2 
1 2 1 
2 3 5 
1 3 3 
3 1 2 
4 2 
1 2 3

样例输出： 
3 
no 
这题除了考并查集，其实也是对kruskal算法的运用。如果大家知道kruskal，就知道首先应该是按距离排序，然后每次选择最短路径连接，一点点成为树的合并，最后合成为一棵最小生成树。代码如下：

import java.util.Comparator;import java.util.Scanner;//存储边的结构，u->v距离为lenclass Edg{    int u;    int v;    int len;}public class Main{    public static void main(String[] args) {        Scanner sc =  new Scanner(System.in);        while(sc.hasNext()){            int N =  sc.nextInt();            int M = sc.nextInt();            int root[] = new int[N+1];            for(int i=1;i<N+1;i++){                root[i]=i;            }            Edg[] edg = new Edg[M];            //边的输入             for(int i=0;i<M;i++){                edg[i] = new Edg();                edg[i].u = sc.nextInt();                edg[i].v = sc.nextInt();                edg[i].len = sc.nextInt();               }             //将边按路径排序             java.util.Arrays.sort(edg, new Comparator<Edg>() {                @Override                public int compare(Edg a, Edg b) {                    if(a.len>b.len){                        return 1;                    }else if(a.len<b.len){                        return -1;                    }else{                        return 0;                    }                }            });             int sum=0;             int eds = 0;//合并的生成树中的边树             for(int i=0;i<M;i++){             //查看u/v根节点是否相等，如果相等表示他们已经连通。                 int rootu = find(root,edg[i].u);                 int rootv = find(root,edg[i].v);                 if(rootu!=rootv){//不连通，则合并两棵树，其实也就是将u节点所在的树合并到v中                     root[rootu]=rootv;                                                  eds++;                     sum+=edg[i].len;//最小生成树中的连通距离                 }                 //如果合成的生成树边树等于节点总数N-1，则已经是最小生成树。                 if(eds==N-1){                     break;                 }             }             if(eds==N-1){               System.out.println(sum);             }else{                 System.out.println("no");             }        }    }    private static int find(int[] root, int x) {        return root[x]==x?x:(root[x]=find(root,root[x]));    }}
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

总结

以上是并查集中比较重要的算法，对于最近公共祖先的问题，在我之前有专门有几篇博客讲解了，大家如果有必要可以在我的博客目录中查找。上面的题目在九度oj中可以找到，但是Java无法AC，我改成C++可以AC。讲的不是特别明白，也可能有误，欢迎大家拍砖！！！