【LeetCode】128. 最长连续序列——哈希的应用(3)

Problem: 128. 最长连续序列

1、思路

我会用一种做题者的思路来去看待这道题。

我们在乍一看到这道题的时候，看到它的时间复杂度要求为O(N)，然后又要求去找序列(就是让你判断这个数的前面一个数在不在这个数组里，这个数的后面一个数在不在数组里）。按照我们平时暴力的做法(也是最先想到的做法)，遍历一个O(N)，然后判断每个元素在不在又是O(N)，然后有可能会有N个元素，这样N* N *N最坏的情况就都有可能是O(N^3)了。要我们找序列，又要我们O(N)，这不扯淡么。

因为所谓O(N)的复杂度，就是要让你一遍过，或者你能说出来几遍过(也即常数个O(N)，即O(kN)，k为常数)，所以，我们说要你说常数遍过就有些扯淡了。

这个时候，我们就可以想到用时间换空间的思想。 并且，用哈希表的存储这样一个空间，来换遍历查找的时间，是一个非常暴力且不要脸的做法(但是并不妨碍我说这种做法好哈哈哈哈)。说它不要脸，是因为它简单易行。

什么意思？简单举个例子：假如有个数组，你要找比某个元素大1(或者小1)的元素在不在该数组里面，按照最粗暴的方法，那么你需要遍历整个数组，也就是O(N)的时间复杂度。但是如果你用哈希的话，那就变成O(1)啦！

那么，现在对于数组内的每一个元素，我都要去找比它小1的元素在不在该数组里，如果按照原来的方法，我需要O(N*2)的时间复杂度。但是如果我用了哈希表，我就一下子变成了O(N)了。

没用什么多难的思想（即没有怎么多人为的操作，参见DP的某些题目），但是就轻轻松松完成了复杂度由时间向空间的转化。所以说，它很不要脸哈哈哈哈哈。

我们就是用这样一个核心的思想来去做这道题。

2、解题方法

在一开始拿到这道题，并且明确了哈希表有这样一个功能之后，最先想到的，是用unordered_map这样一个结构。因为不是要O(N)嘛，我是用哈希来去降了一次，但是我似乎遍历一遍数组需要O(N)，但还需要去递归地去找 比每个元素小1的、小2的、小3的…小n的 在不在里面，这不是还是有个O(N)吗，然后合在一块不还是O(N^2)？

然后我想着，前面的第一次O(N)是不可避免的（因为你总要遍历整个数组嘛）。但是后面的那个O(N)，可不可以用unordered_map里的 <key, value>来去标记我每个元素有没有遍历过呢？如果说，我在某次找比某个元素小1的、小2的…小n的时候遍历过了，那么我在第一个遍历数组的那个O(N)循环里就不需要再去遍历它了，但是这就有可能造成新的问题，就是我怎么知道谁是最长的呢？比如对于样例：

[100, 4, 200, 1, 3, 2, 5]

如果在外层第一层循环遍历到4的时候，我依靠哈希在内层找到了后面的1，2，3，并且标记它们已经被遍历过。那后面第一层循环再遍历到数组1，2，3的时候就直接跳过。但是如果我后面的5来了，我该怎么办呢？而且我这个时候4已经遍历过了。

如果大家能够明白我上面想表达的意思了，那么大家可以先不着急往下看，自己想一想该如何做。

其实做法有很多啦。在这里呢，就说两种。

1.是采用计数的方法。我们刚刚不是用了unordered_map嘛，那就可以在value中来去存储长度的相关信息。这样，在5来了之后，将它现在已有的长度加上4中的value中存储的长度，作为5的长度来使用。

2.这个做法就更加简单粗暴了。就是如果这个数不是边界，就别理它，只有当它是边界的时候我们再去给它计数。什么意思呢？就是说，假如我们在内循环中，往比每个数小的那个方向去找（就是对于每个元素，我们统一找比它小1的、小2的、小3的…，而不是大1的，大2的，大3的…），那么如果我们能在该数组中找到有比它大1的元素存在，我们就直接跳过它，就不理它。直到我们在数组中不能够找到有比它大的元素存在，说明它就是边界了，这时我们才开始计数。

这里笔者就对第二种思路进行展开分析了哈。可以确立以下思路：

1)先把数组中所有的数都放到哈希表里面，直接放。

2)然后用几个 if 和 else 就搞定了

然后，对于数组的每一个元素，如果它的value值不是false（一开始初始化的时候都是true），\
判断每个数比它大1的和比它小1的是否在里面
if 比它大1:  
    if 它的比它大1没有在这数组里面(也就是不存在):
        then 它是最后一个元素 从它开始计数;再开始判断比它小1的数是否存在
        【
            if 比它小1的数在这里面 :
                then 继续往前找(找小2的、小3的...)，并且找的那个元素的\
                value值赋值false，这样在外层“对于每一个元素中”看到它就会直接跳过了。 
            else:
                就不管，跳过
        】
    else if 比它大1的数在这里面:
        then 它不是最后一个元素，别理它，直接跳过

但是我又发现，这个false赋值的好像很鸡肋的样子。因为你会发现最后所有的value值是false的元素，都是"比它大1的数"存在的。那当我在外层循环遍历到这个value值是false的元素的时候，如果跟我不用这个false，我直接去找比它大1的数存不存在，如果存在，那我也仍然是可以直接跳过它，这个查找的时间复杂度也是O(1)。

所以这个false就完全没有必要了。在外层循环，我只要去找比它大1的元素存不存在就行了。实际上我在上述的伪代码中已经去找比它大1的数在不在了。

也就是说，思路简而言之，一句话：对于数组的每个元素，查找：1)比它大1的数不在里面，2)比它小1的数在里面，只有当1）2）条件都满足的时候，我们才开始内循环遍历（就是去找比它小1的、小2的…小n的在不在这里面），否则直接跳过该元素。然后最后找到最长的序列。

3、复杂度

时间复杂度:

以算法的角度来看，

1、把这些数放到哈希表里面，需要O(N);（步骤1）

2、再次遍历一个数组，也是O(N)。 （步骤2）

3、对于哈希表中的每个元素，如果它前一个数不在里面，直接跳过，O(1)。如果在里面，那么会递归去找之前的数，O(N)，但是，可以预见这些数在未来的过程(步骤2)中就不会再次去遍历了。

因此是时间复杂度是$O(N)$。

不过很多人觉得这种说法可能会有些牵强，那我们换一种说法：

以数组中每个数的视角来去看，它最多会被遍历四次（放进哈希表一次，外层遍历一次，内层遍历一次，被来自比它小1的那个数的查找一次）

这样的话，就显然是$O(N)$了。

空间复杂度:

$O(n)$，哈希表的空间复杂度，没什么好说的。

4、Code

C++版本：

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        int Max = 0;
        unordered_set<int> mp;
        for(int i = 0;i < nums.size();i++){
            mp.insert(nums[i]);
        }
        for(int i = 0;i < nums.size();i++){
            if(mp.find(nums[i] + 1) == mp.end()){
                int length = 1;
                while(mp.find(nums[i] - length) != mp.end()){
                    length++;
                }
                Max = max(Max, length);
            }
            else{
                continue;
            }
        }
        return Max;
    }
};

Java版本：

class Solution {
    public int longestConsecutive(int[] nums) {
        int max = 0;
        HashSet<Integer> set = new HashSet<>();
        
        for (int num : nums) {
            set.add(num);
        }
        
        for (int num : nums) {
            if (!set.contains(num + 1)) {
                int length = 1;
                
                while (set.contains(num - length)) {
                    length++;
                }
                
                max = Math.max(max, length);
            }
        }
        
        return max;
    }
}

Python版本：

class Solution(object):
    def longestConsecutive(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        max_length = 0
        num_set = set(nums)
        
        for num in nums:
            if num - 1 not in num_set:
                length = 1
                
                while num + length in num_set:
                    length += 1
                    
                max_length = max(max_length, length)
        
        return max_length

最后，可以来稍微总结一下，这道题的核心或者价值我认为还是在于用哈希来空间换时间的做法。如果不用哈希，那么判断前一个数在不在里面，将会用到O(N)；判断后一个数在不在里面，也需要O(N)，那么如果用哈希来查找，这两步的操作就都变成O(1)了->数组的频繁查找工作。至于后面的微调，我们有哈希表，于是乎大家只要去从“第一次遍历过的，第二次就不要遍历了”的角度去考虑就行了，也因为有哈希表，也就能有了这样考虑的余地。顺理成章地就出来了。

如果喜欢我的题解，就给我个关注吧，我会持续为大家带来更优质的分享。