JAVA实践并查集

前言

并查集类似数学中的集合，如果是两个集合相交，那就把这两个集合合并成一个集合。

社交网络中推荐可能认识的人，可能是类似原理。

二狗子与B是好友{二狗子， B}

B与A是好友{B，A}

两个相交是B

所以合并，{二狗子，B，A}

系统就可能会将B以可能认识的人给二狗子

发现了不错的文章：

参考链接：

http://blog.csdn.net/dm_vincent/article/details/7655764

http://blog.csdn.net/dm_vincent/article/details/7769159

实现功能

来及《啊哈，算法》

擒贼先擒王---并查集的应用
* 小哼的家乡出现多次抢劫事件，强盗人数众多，警察想查清楚到底有几个犯罪团伙是非常困难的，然而还是搜到了一些线索：
* 10个强盗
* 1号强盗与2号强盗是同伙
* 3号强盗与4号强盗是同伙
* 5号强盗与2号强盗是同伙
* 4号-6号
* 2号-6号
* 8号-7号
* 9号-7号
* 1号-6号
* 2号-4号
* 强盗同伙的同伙也是同伙，现在需要查出有几个独立的犯罪集团。

实现检索出独立犯罪集团的个数。

中文版参考

/**
* 思路来自《啊哈，算法》，我作为初学者，只是复述一遍加深印象。
*
* 首先，假设10个强盗互不认识，每个人的BOSS都是自己，我们要找出每个独立犯罪集团的BOSS，及其下属
* 使用一个一维数组 r 存储
*      每个下标代表强盗编号
*      下标对应的值代表其BOSS
*      例如r[2]=5   表示2号强盗的BOSS是5号强盗
*
* 初始状态
*  index:    1  2  3  4  5  6  7  8  9  10
*      r:   {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
*
* 然后，我们逐条线索处理。
* 此处我们假设每一对强盗中，第二个服从第一个，如说到9号-7号。则7号服从9号。
*
* 1号-2号：
*          令2号强盗的BOSS为1号
*          r[2] = 1        // Again，每个下标代表强盗编号，下标对应的值代表其BOSS
*
*          index:    1  2  3  4  5  6  7  8  9  10
*              r:   {1, 1, 3, 4, 5, 6, 7, 8, 9, 10}
*
* 3号-4号：
*          令3号强盗的BOSS为4号
*          r[3] = 4
*
*          index:    1  2  3  4  5  6  7  8  9  10
*              r:   {1, 1, 4, 4, 5, 6, 7, 8, 9, 10}
*
* 5号-2号：
*          此处应是令2号强盗的BOSS为5号，然而
*          2号强盗的BOSS已经是1号了，如何解决？
*
*          方法是，既然2号强盗的BOSS是1号，那么5号去收服2号的BOSS 1号强盗 好了。
*          即r[1] = 5
*
*          index:    1  2  3  4  5  6  7  8  9  10
*              r:   {5, 1, 4, 4, 5, 6, 7, 8, 9, 10}
*
* --------------------------------------------------------------------------------------
*          此后，凡是碰需要收服的强盗BOSS另有其人的，都是去找最顶层的BOSS
*
*          例如8号需要收服9号
*          9号的BOSS是6号
*          6号的BOSS是1号
*          那么。8号直接去收服1号即可
*          PPPPPS：寻找BOSS的过程是递归的，在此过程中可以将寻找到的BOSS赋值给每一个经过的下属
*          这样下次找BOSS，可以直接一步到位
*          原本的BOSS寻找: 9号→6号→1号
*          经过BOSS的替换，而可以做到：9号→1号
*          术语貌似叫压缩路径
*
*          另一种情况，
*          r[5] = 5
*          r[2] = 5
*
*          r[3] = 3
*          r[6] = 3
*
*          6号本来的BOSS是3号，但是现在他有新的BOSS 2号强盗
*          即：2号-6号，那该怎么办呢？
*          答案是，让6号的BOSS 3号强盗 归顺5号强盗即可
*          即r[3] = 5
*
*          总结一下并查集的思路：
*          从n个集合中，寻找几个独立不相交的大集合。
*          将相交的小集合合并即可
*          合并的思路是，每次都寻找最顶层的祖先
*          例如因为B公司的业务对A公司当前有帮助（相交）
*          A公司收购B公司（合并）
*          只需要让B公司的CEO归属A公司的CEO，不需要对每个职员都处理
*          但是每次B公司员工寻找B公司CEO时，可能需要辗转好几个上司、上司的上司等
*          此时可以优化B公司的员工跨过上司直接找到B公司的CEO。而B公司的CEO对A公司CEO负责。
*
*/

代码实现

public class UnionFind {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] robber = new int[11];
init(robber);
showArray(robber);
int employer, employee;

for (int i = 1; i < robber.length - 1; i++) {
employer = in.nextInt();
employee = in.nextInt();
unionRobber(robber, employer, employee);
}
showArray(robber);
int sum = 0;
for (int i = 1; i < robber.length; i++) {
if (robber[i] == i) {
sum++;
}
}
System.out.println(sum);
}

public static void init(int[] robber) {
for (int i = 1; i < robber.length; i++) {
robber[i] = i;
}
}
public static void showArray(int[] robber) {
for (int i = 1; i < robber.length; i++) {
System.out.print(robber[i] + " ");
}
System.out.println();
}
public static void unionRobber(int[] robber, int employer, int employee) {
//传进来的是小盗贼头目，可能有大BOSS呢，寻找他
int t1 = findBigBoss(robber, employer);
//可能有上司，让上司对大BOSS负责
int t2 = findBigBoss(robber, employee);

//如果我们找到了小盗贼的BOSS
//同时找到了小盗贼头目的BOSS
//并且不是同伙的，那么让小盗贼的BOSS纳入麾下
if (t1 != t2) {
robber[t2] = t1;
}
}
public static int findBigBoss(int[] robber, int pos) {
//如果他的BOSS是自己，不就是大BOSS嘛
if (robber[pos] == pos) {
return pos;
} else {
//寻找他的上级BOSS,寻找过程中压缩路径。即让所有下属直接对顶层BOSS负责
robber[pos] = findBigBoss(robber, robber[pos]);
return robber[pos];
}
}
}

结果

输出：
1 2 3 4 5 6 7 8 9 10
输入：
1 2
3 4
5 2
4 6
2 6
8 7
9 7
1 6
2 4
输出：
5 5 5 5 5 5 8 9 9 10
3

结尾一点

首先一开始看的时候还是有点糊涂的，然后就搜到了开头两篇文章，在了解了应用范围之后，忽然就通了。

大概这是抽象能力不足的表现。

复述的过程中，会感觉到对其思想产生了解，写代码能从整体考虑。

首先我要能找任意盗贼的上司

其次我要能把找到的上司告诉那个盗贼，如果不是同一个上司的话

然后就完了。

END