数组:最多连续数的子集

 
 


 

给一个整数数组, 找到其中包含最多连续数的子集。

=====================================================================
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 }
View Code

 

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

posted @ 2015-09-18 19:45  Uncle_Nucky  阅读(720)  评论(0编辑  收藏  举报