数组：最多连续数的子集

  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 }