数组：最多连续数的子集

【数组分割】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)。

=====================================================================

import java.util.HashMap;
 
/**
* 给一个整数数组， 找到其中包含最多连续数的子集， 比如给：15, 7, 12, 6, 14, 13, 9, 11， 则返回: 5:[11, 12,
* 13,14, 15]
*
*/
public class Main {
 
int[] array; // 存储数字
int[] boss; // array中每个位置上的数字的Boss的位置，同一Boss的各个数字，表明他们在同一个连续数的子集中
int[] heeler; // array中每个位置上的数字拥有的手下的数量
HashMap<Integer, Integer> map; // key为array中各个位置上对应的数字，value为该数字在数组中的位置
 
public Main(int[] array) {
this.array = array;
boss = new int[array.length];
// 初始化各个位置上的数字的Boss为自己
for (int i = 0; i < array.length; i++) {
boss[i] = i;
}
heeler = new int[array.length];
// 初始化每个节点上的数字的手下只有一个，即自己
for (int i = 0; i < array.length; i++) {
heeler[i] = 1;
}
// 利用HashMap来存储数字以及所在位置这种关系的目的是
// 能快速找到任何一个数字的兄弟数字所在的数字
map = new HashMap<Integer, Integer>();
for (int i = 0; i < array.length; i++) {
map.put(array[i], i);
}
}
 
// 找到数组中某个位置的最大Boss的位置
int findBoss(int x) {
// 如果某个位置上的数字的Boss就是自己，则表明他就是Boss
// 否则 ，必须找到他的直属Boss的Boss,并更最大的boss为自己的直属boss
if (x != boss[x])
boss[x] = findBoss(boss[x]);
return boss[x];
}
 
// 合并队伍:
// 规则：当位置x的boss拥有的heeler，比位置y的boss拥有的heeler少时，
// 则将位置x的boss下的所有heeler归并到位置y的boss下
// 因此位置y的boss拥有的heeler数量为原有的数量，加上位置x上的boss拥有的heeler数量
// 反之类似
public void union(int x, int y) {
int bossOfx = findBoss(x); // 找出位置x的最大boss
int bossOfy = findBoss(y);
int numHeeler_bossOfx = heeler[bossOfx]; // 找出位置x的最大boss下的heeler数量
int numHeeler_bossOfy = heeler[bossOfy];
// 当位置x与位置y的boss相同时，表明他们本来就是同一团队，不需要合并
if (bossOfx == bossOfy)
return;
if (numHeeler_bossOfx >= numHeeler_bossOfy) {
boss[bossOfy] = bossOfx;
heeler[bossOfx] += heeler[bossOfy];
}
if (numHeeler_bossOfx < numHeeler_bossOfy) {
boss[bossOfx] = bossOfy;
heeler[bossOfy] += heeler[bossOfx];
}
}
 
// 求最大子集
public void getMax() {
for (int i = 0; i < array.length; i++) {
int leftBrother = array[i] - 1;
//如果位置i的数字存在比自己小于1的数字，则进行合并
if (map.containsKey(leftBrother)) {
int place = map.get(leftBrother);
union(place, i);
}
int rightBrother = array[i] + 1;
//如果位置i的数字存在比自己大于1的数字，则进行合并
if (map.containsKey(rightBrother)) {
int place = map.get(rightBrother);
union(i, place);
}
}
 
int max = 0; // 最大子集个数
int bo = 0; // 最大子集的boss
for (int i = 0; i < array.length; i++) {
if (heeler[i] > max) {
max = heeler[i];
bo = i;
}
}
System.out.println("最大子集个数为： " + max);
for (int i = 0; i < array.length; i++) {
if (boss[i] == bo) {
System.out.print(array[i] + " ");
}
}
}
 
public static void main(String[] args) {
int[] arr = new int[] { 15, 7, 12, 6, 14, 13, 9, 11 };
Main test = new Main(arr);
test.getMax();
}
}

 

=====================================================================