【数组分割】http://blog.csdn.net/hackbuteer1/article/details/7638305
给一个整数数组， 找到其中包含最多连续数的子集。
=====================================================================
map<int, int>，它的key是一个起始的数字，value是这个起始数字起连续的个数。这样这个数组遍历一遍下来，只要map维护好了，自然就能得到最长的连续子串了，并且算法复杂度应该是O(n)。
取出当前的整数，在map里看一下是否已经存在，若存在则直接取下一个，不存在转2 (为什么要看是否已经存在，因为题目没有说不会有重复的数字。)
查看下map里面当前数字的前一个是否存在，如果存在，当前的最长长度就是前一个最长长度+1
查看下map里面当前数字的后一个是否存在，如果存在，那么就将以下一个数字开始的子串的最后一个更新下，因为本来没有连上的2个子串，因为当前数字的出现连起来了
接着再看下前面数字是否存在，如果存在，就更新以这个数字结尾的子串的第一个数字的连续子串长度，原因同上
代表的是包含它的连续序列的长度，但不是每个都up to date的。只维护了那个序列中的开始和最后就够了，中间没有意义。
=====================================================================
并查集可以方便地进行以下三种操作：
1、Make(x)：把每一个元素初始化为一个集合，初始化后每一个元素的父节点就是它本身。
2、Find(x)：查找一个元素所在的集合，一个元素所在的集合用这个集合的祖先节点来标识。判断两个元素是否属于同一个集合，只要看他们所在集合的祖先节点是否相同即可。
3、Union(x, y)：合并x、y所在的两个集合，先利用Find()找到两个集合的祖先，若这两个祖先节点不是同一个节点，将其中一个祖先节点指向另一个祖先节点即可。（具体哪个祖先指向哪个祖先可以根据实际情况而定）
并查集的优化：在Find函数中，每次找祖先节点的复杂度是O(n)。当我们经过递归找祖先节点的时候，顺便把这条路径上的所有子孙节点都直接指向祖先，这样下次Find的时候复杂度就变成了O(1)。
=====================================================================
1 import java.util.HashMap;
2
3 /**
4 * 给一个整数数组， 找到其中包含最多连续数的子集， 比如给：15, 7, 12, 6, 14, 13, 9, 11， 则返回: 5:[11, 12,
5 * 13,14, 15]
6 *
7 */
8 public class Main {
9
10 int[] array; // 存储数字
11 int[] boss; // array中每个位置上的数字的Boss的位置，同一Boss的各个数字，表明他们在同一个连续数的子集中
12 int[] heeler; // array中每个位置上的数字拥有的手下的数量
13 HashMap<Integer, Integer> map; // key为array中各个位置上对应的数字，value为该数字在数组中的位置
14
15 public Main(int[] array) {
16 this.array = array;
17 boss = new int[array.length];
18 // 初始化各个位置上的数字的Boss为自己
19 for (int i = 0; i < array.length; i++) {
20 boss[i] = i;
21 }
22 heeler = new int[array.length];
23 // 初始化每个节点上的数字的手下只有一个，即自己
24 for (int i = 0; i < array.length; i++) {
25 heeler[i] = 1;
26 }
27 // 利用HashMap来存储数字以及所在位置这种关系的目的是
28 // 能快速找到任何一个数字的兄弟数字所在的数字
29 map = new HashMap<Integer, Integer>();
30 for (int i = 0; i < array.length; i++) {
31 map.put(array[i], i);
32 }
33 }
34
35 // 找到数组中某个位置的最大Boss的位置
36 int findBoss(int x) {
37 // 如果某个位置上的数字的Boss就是自己，则表明他就是Boss
38 // 否则 ，必须找到他的直属Boss的Boss,并更最大的boss为自己的直属boss
39 if (x != boss[x])
40 boss[x] = findBoss(boss[x]);
41 return boss[x];
42 }
43
44 // 合并队伍:
45 // 规则：当位置x的boss拥有的heeler，比位置y的boss拥有的heeler少时，
46 // 则将位置x的boss下的所有heeler归并到位置y的boss下
47 // 因此位置y的boss拥有的heeler数量为原有的数量，加上位置x上的boss拥有的heeler数量
48 // 反之类似
49 public void union(int x, int y) {
50 int bossOfx = findBoss(x); // 找出位置x的最大boss
51 int bossOfy = findBoss(y);
52 int numHeeler_bossOfx = heeler[bossOfx]; // 找出位置x的最大boss下的heeler数量
53 int numHeeler_bossOfy = heeler[bossOfy];
54 // 当位置x与位置y的boss相同时，表明他们本来就是同一团队，不需要合并
55 if (bossOfx == bossOfy)
56 return;
57 if (numHeeler_bossOfx >= numHeeler_bossOfy) {
58 boss[bossOfy] = bossOfx;
59 heeler[bossOfx] += heeler[bossOfy];
60 }
61 if (numHeeler_bossOfx < numHeeler_bossOfy) {
62 boss[bossOfx] = bossOfy;
63 heeler[bossOfy] += heeler[bossOfx];
64 }
65 }
66
67 // 求最大子集
68 public void getMax() {
69 for (int i = 0; i < array.length; i++) {
70 int leftBrother = array[i] - 1;
71 //如果位置i的数字存在比自己小于1的数字，则进行合并
72 if (map.containsKey(leftBrother)) {
73 int place = map.get(leftBrother);
74 union(place, i);
75 }
76 int rightBrother = array[i] + 1;
77 //如果位置i的数字存在比自己大于1的数字，则进行合并
78 if (map.containsKey(rightBrother)) {
79 int place = map.get(rightBrother);
80 union(i, place);
81 }
82 }
83
84 int max = 0; // 最大子集个数
85 int bo = 0; // 最大子集的boss
86 for (int i = 0; i < array.length; i++) {
87 if (heeler[i] > max) {
88 max = heeler[i];
89 bo = i;
90 }
91 }
92 System.out.println("最大子集个数为： " + max);
93 for (int i = 0; i < array.length; i++) {
94 if (boss[i] == bo) {
95 System.out.print(array[i] + " ");
96 }
97 }
98 }
99
100 public static void main(String[] args) {
101 int[] arr = new int[] { 15, 7, 12, 6, 14, 13, 9, 11 };
102 Main test = new Main(arr);
103 test.getMax();
104 }
105 }
=====================================================================