[Leetcode] Longest Consecutive Sequence 略详细 (Java)

题目参见这里 https://leetcode.com/problems/longest-consecutive-sequence/

这个题目我感觉很难，看了半天别人写的答案，才明白个所以然。下面的代码是我自己的改编，写的好像很复杂的样子，主要也是为了方便自己理解，耐着性子看完，应该就理解了。

【个人分析】：

　　题目难度主要是要求O(N)完成。本来最自然的想法是先排序然后再去扫一遍得到结果，可是这样，明显就是O(NlgN)。怎么样从NlgN 提高到O(N)呢？  ==> 空间换时间，空间从O(1) 变成 O(N)  ==> 变成O(N)的空间的话，首推哈希表  ==> 如果是用哈希表的话，用序列中的数字做 map 中的 key 是比较自然的想法，所以问题就集中到了，用什么来做 map 中的 value 上来。

【代码注释】：

　　  上面的主线基本只能推进到那里了，剩下的就是对题目本身的挖掘。我在这里用的是类似动态规划里面常用的前缀、后缀的那种思路。新建了一个类 Bound 来作为 map 中的value , （当然可以不用新建类，直接用一个 list 来做。新建一个类是为了写起来清楚）。对于map中的一个值 num, 它对应的value 是Bound, Bound.maxRangeAsLeftBound 是说，到目前为止，以 num 作为一个连续序列的左边界的所有可能中最长的那个，maxRangeAsRighgBound类似的道理。举个例子，如果有 map[3] = {maxRangeAsLeftBound = 2, maxRangeAsRightBound=3}, 那么就是说存在连续序列【3，4】，和连续序列【1，2，3】

　　 这个算法的精髓，我个人认为，在于只抓一个范围的两头，对于在范围里面的数字置之不理。什么意思？ 假设数组是【4，3，1，2】 ，在依次处理完4，3，1之后，我们要处理2，加入2之后，整个数组中，最长的连续序列将变成，【1-4】。此时，我们只需要更新1，和 4在map中对于的value, 而对于3，这个数夹在1-4之间，对于它在map中的value，我们不必再费神去更新。

　　为什么？ 你想嘛，假设后面出现了一个更长的序列，是以3 作为左边界，即 maxRange = [3,...], 那么让1做这个范围的边界岂不是可以得到一个更长的【1，2，3...]？ 同样的道理，如果maxRange = [...3], 那么让4作为这个范围的右边界，范围也会变得更长。所以，我们不会再用到 3 在map 中对应的 value， 所以也就不用再去更新它了。

　　正是因为这样，整个算法的复杂度才是O(N), 如果对于任意一个数字，都要去更新range中所有数字对应的value,那么复杂度就会变成平方。

【实际例子】:  int[] nums = {4,1,3,2}, int resultExpected = 4

 1 public class Solution {
 2     public int longestConsecutive(int[] nums) {
 3         int result = 0;
 4         Map<Integer, Bound> rangeMap = new HashMap<Integer, Bound>();
 5
 6         for (int i = 0; i < nums.length; i++) {
 7             int num = nums[i];
 8             if ( !rangeMap.containsKey(num) ) {
 9                 int maxRangeToThisNumber   = 1;
10                 int maxRangeFromThisNumber = 1;
11                 // can this number be a right boundary of a range ?
12                 if (rangeMap.containsKey(num - 1)) {
13                     maxRangeToThisNumber += rangeMap.get(num - 1).maxRangeAsRightBound;
14                 }
15                 // can this number be a left boundary of a range?
16                 if (rangeMap.containsKey(num + 1)) {
17                     maxRangeFromThisNumber += rangeMap.get(num + 1).maxRangeAsLeftBound;
18                 }
19                 int maxRangeIncludeThisNumber =
20                         maxRangeToThisNumber + maxRangeFromThisNumber - 1;
21
22                 // update range map
23                 Bound bound = new Bound(maxRangeFromThisNumber, maxRangeToThisNumber);
24                 rangeMap.put(num, bound);
25
26                 // num is not the right boundary of max range including num
27                 if (maxRangeFromThisNumber != 1) {
28                     // update the range of number at the right bound
29                     int rightEnd = maxRangeFromThisNumber + num - 1;
30                     Bound boundRight = rangeMap.get(rightEnd);
31                     boundRight.maxRangeAsRightBound = maxRangeIncludeThisNumber;
32                     rangeMap.put(rightEnd, boundRight);
33                 }
34                 if (maxRangeToThisNumber != 1) {
35                     int leftEnd = num - maxRangeToThisNumber + 1;
36                     Bound boundLeft = rangeMap.get(leftEnd);
37                     boundLeft.maxRangeAsLeftBound = maxRangeIncludeThisNumber;
38                     rangeMap.put(leftEnd, boundLeft);
39                 }
40
41                 // update global max
42                 result = Math.max(result, maxRangeIncludeThisNumber);
43             }
44         }
45
46         return result;
47     }
48
49     public class Bound {
50         public int maxRangeAsRightBound = 0;
51         public int maxRangeAsLeftBound = 0;
52         public Bound(int _maxRangeAsLeftBound, int _maxRangeAsRightBound) {
53             maxRangeAsLeftBound = _maxRangeAsLeftBound;
54             maxRangeAsRightBound = _maxRangeAsRightBound;
55         }
56     }
57
58 }