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 ) O(N) O(N)。
不过很多人觉得这种说法可能会有些牵强,那我们换一种说法:
以数组中每个数的视角来去看,它最多会被遍历四次(放进哈希表一次,外层遍历一次,内层遍历一次,被来自比它小1的那个数的查找一次)
这样的话,就显然是 O ( N ) O(N) O(N)了。
空间复杂度:
O ( n ) 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)了->数组的频繁查找工作。至于后面的微调,我们有哈希表,于是乎大家只要去从“第一次遍历过的,第二次就不要遍历了”的角度去考虑就行了,也因为有哈希表,也就能有了这样考虑的余地。顺理成章地就出来了。
如果喜欢我的题解,就给我个关注吧,我会持续为大家带来更优质的分享。