daily leetcode - longest-consecutive-sequence - !
题目地址
https://leetcode.com/problems/longest-consecutive-sequence/
题目描述
Given an unsorted array of integers, find the length of the longest consecutive elements sequence.
Your algorithm should run in O( n ) complexity.
Example:
Input: [100, 4, 200, 1, 3, 2]
Output: 4
Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.
思路
这道题要求求最长连续序列,并给定了O(n)复杂度限制,我们的思路是,使用一个集合HashSet存入所有的数字,然后遍历数组中的每个数字,如果其在集合中存在,那么将其移除,然后分别用两个变量pre和next算出其前一个数跟后一个数,然后在集合中循环查找,如果pre在集合中,那么将pre移除集合,然后pre再自减1,直至pre不在集合之中,对next采用同样的方法,那么next-pre-1就是当前数字的最长连续序列,更新res即可。这里再说下,为啥当检测某数字在集合中存在当时候,都要移除数字。这是为了避免大量的重复计算,就拿题目中的例子来说吧,我们在遍历到4的时候,会向下遍历3,2,1,如果都不移除数字的话,遍历到1的时候,还会遍历2,3,4。同样,遍历到3的时候,向上遍历4,向下遍历2,1,等等等。如果数组中有大量的连续数字的话,那么就有大量的重复计算,十分的不高效,所以我们要从HashSet中移除数字,代码如下:
C++ 解法一:
class Solution {
public:
int longestConsecutive(vector<int>& nums) {
int res = 0;
unordered_set<int> s(nums.begin(), nums.end());
for (int val : nums) {
if (!s.count(val)) continue;
s.erase(val);
int pre = val - 1, next = val + 1;
while (s.count(pre)) s.erase(pre--);
while (s.count(next)) s.erase(next++);
res = max(res, next - pre - 1);
}
return res;
}
};
Java 解法一:
public class Solution {
public int longestConsecutive(int[] nums) {
int res = 0;
Set<Integer> s = new HashSet<Integer>();
for (int num : nums) s.add(num);
for (int num : nums) {
if (s.remove(num)) {
int pre = num - 1, next = num + 1;
while (s.remove(pre)) --pre;
while (s.remove(next)) ++next;
res = Math.max(res, next - pre - 1);
}
}
return res;
}
}
我们也可以采用哈希表来做,刚开始HashMap为空,然后遍历所有数字,如果该数字不在HashMap中,那么我们分别看其左右两个数字是否在HashMap中,如果在,则返回其哈希表中映射值,若不在,则返回0,虽然我们直接从HashMap中取不存在的映射值,也能取到0,但是一旦去取了,就会自动生成一个为0的映射,那么我们这里再for循环的开头判断如果存在映射就跳过的话,就会出错。然后我们将left+right+1作为当前数字的映射,并更新res结果,同时更新num-left和num-right的映射值。
下面来解释一下为啥要判断如何存在映射的时候要跳过,这是因为一旦某个数字创建映射了,说明该数字已经被处理过了,那么其周围的数字很可能也已经建立好了映射了,如果再遇到之前处理过的数字,再取相邻数字的映射值累加的话,会出错。举个例子,比如数组 [1, 2, 0, 1],当0执行完以后,HashMap中的映射为 {1->2, 2->3, 0->3},可以看出此时0和2的映射值都已经为3了,那么如果最后一个1还按照原来的方法处理,随后得到结果就是7,明显不合题意。还有就是,之前说的,为了避免访问不存在的映射值时,自动创建映射,我们使用m.count() 先来检测一下,只有存在映射,我们才从中取值,否则就直接赋值为0,参见代码如下:
C++ 解法二:
class Solution {
public:
int longestConsecutive(vector<int>& nums) {
int res = 0;
unordered_map<int, int> m;
for (int num : nums) {
if (m.count(num)) continue;
int left = m.count(num - 1) ? m[num - 1] : 0;
int right = m.count(num + 1) ? m[num + 1] : 0;
int sum = left + right + 1;
m[num] = sum;
res = max(res, sum);
m[num - left] = sum;
m[num + right] = sum;
}
return res;
}
};
Java 解法二:
public class Solution {
public int longestConsecutive(int[] nums) {
int res = 0;
Map<Integer, Integer> m = new HashMap<Integer, Integer>();
for (int num : nums) {
if (m.containsKey(num)) continue;
int left = m.containsKey(num - 1) ? m.get(num - 1) : 0;
int right = m.containsKey(num + 1) ? m.get(num + 1) : 0;
int sum = left + right + 1;
m.put(num, sum);
res = Math.max(res, sum);
m.put(num - left, sum);
m.put(num + right, sum);
}
return res;
}
}
思路2
这是一道最最长连续数字序列长度的题目, 官网给出的难度是hard
.
符合直觉的做法是先排序,然后用一个变量记录最大值,遍历去更新最大值即可,
代码:
if (nums.length === 0) return 0;
let count = 1;
let maxCount = 1;
// 这里其实可以不需要排序,这么做只不过是为了方便理解
nums = [...new Set(nums)].sort((a, b) => a - b);
for (let i = 0; i < nums.length - 1; i++) {
if (nums[i + 1] - nums[i] === 1) {
count++;
} else {
if (count > maxCount) {
maxCount = count;
}
count = 1;
}
}
return Math.max(count, maxCount);
但是需要排序时间复杂度会上升,题目要求时间复杂度为 O(n),
那么我们其实可以不用排序去解决的。
思路就是将之前”排序之后,通过比较前后元素是否相差 1 来判断是否连续“的思路改为
不排序而是直接遍历,然后在内部循环里面查找是否存在当前值的邻居元素
,但是马上有一个
问题,内部我们查找是否存在当前值的邻居元素
的过程如果使用数组时间复杂度是 O(n),
那么总体的复杂度就是 O(n^2),完全不可以接受。怎么办呢?
我们换个思路,用空间来换时间。比如用类似于 hashmap 这样的数据结构优化查询部分,将时间复杂度降低到 O(1), 代码见后面代码部分
关键点解析
- 空间换时间
代码
/*
* @lc app=leetcode id=128 lang=javascript
*
* [128] Longest Consecutive Sequence
*
* https://leetcode.com/problems/longest-consecutive-sequence/description/
*
* algorithms
* Hard (40.98%)
* Total Accepted: 200.3K
* Total Submissions: 484.5K
* Testcase Example: '[100,4,200,1,3,2]'
*
* Given an unsorted array of integers, find the length of the longest
* consecutive elements sequence.
*
* Your algorithm should run in O(n) complexity.
*
* Example:
*
*
* Input: [100, 4, 200, 1, 3, 2]
* Output: 4
* Explanation: The longest consecutive elements sequence is [1, 2, 3, 4].
* Therefore its length is 4.
*
*
*/
/**
* @param {number[]} nums
* @return {number}
*/
var longestConsecutive = function(nums) {
nums = new Set(nums);
let max = 0;
let y = 0;
nums.forEach(x => {
// 说明x是连续序列的开头元素
if (!nums.has(x - 1)) {
y = x + 1;
while (nums.has(y)) {
y = y + 1;
}
max = Math.max(max, y - x); // y - x 就是从x开始到最后有多少连续的数字
}
});
return max;
};
本文参考自:
https://github.com/grandyang/leetcode/ &
https://github.com/azl397985856/leetcode
思路3
方法一:哈希表
思路和算法
我们考虑枚举数组中的每个数 x
,考虑以其为起点,不断尝试匹配 x+1
, x+2
, ⋯
是否存在,假设最长匹配到了 x+y
,那么以 x
为起点的最长连续序列即为 x
, x+1
, x+2
,⋯
,x+y
,其长度为 y+1
,我们不断枚举并更新答案即可。
对于匹配的过程,暴力的方法是 O(n)
遍历数组去看是否存在这个数,但其实更高效的方法是用一个哈希表存储数组中的数,这样查看一个数是否存在即能优化至 O(1)
的时间复杂度。
仅仅是这样我们的算法时间复杂度最坏情况下还是会达到 O(n^2)
(即外层需要枚举 O(n)
个数,内层需要暴力匹配 O(n)
次),无法满足题目的要求。但仔细分析这个过程,我们会发现其中执行了很多不必要的枚举,如果已知有一个 x
, x+1
, x+2
, ⋯
,x+y
的连续序列,而我们却重新从 x+1
,x+2
或者是 x+y
处开始尝试匹配,那么得到的结果肯定不会优于枚举 x
为起点的答案,因此我们在外层循环的时候碰到这种情况跳过即可。
那么怎么判断是否跳过呢?由于我们要枚举的数 x
一定是在数组中不存在前驱数 x-1
的,不然按照上面的分析我们会从 x-1
开始尝试匹配,因此我们每次在哈希表中检查是否存在 x-1
即能判断是否需要跳过了。
增加了判断跳过的逻辑之后,时间复杂度是多少呢?外层循环需要 O(n)
的时间复杂度,只有当一个数是连续序列的第一个数的情况下才会进入内层循环,然后在内层循环中匹配连续序列中的数,因此数组中的每个数只会进入内层循环一次。根据上述分析可知,总时间复杂度为 O(n)
,符合题目要求。
class Solution {
public int longestConsecutive(int[] nums) {
Set<Integer> num_set = new HashSet<Integer>();
for (int num : nums) {
num_set.add(num);
}
int longestStreak = 0;
for (int num : num_set) {
if (!num_set.contains(num - 1)) {
int currentNum = num;
int currentStreak = 1;
while (num_set.contains(currentNum + 1)) {
currentNum += 1;
currentStreak += 1;
}
longestStreak = Math.max(longestStreak, currentStreak);
}
}
return longestStreak;
}
}
复杂度分析
时间复杂度:O(n)
,其中 nn 为数组的长度。具体分析已在上面正文中给出。
空间复杂度:O(n)
。哈希表存储数组中所有的数需要 O(n)
的空间。
- 作者:LeetCode-Solution
- 链接:https://leetcode-cn.com/problems/longest-consecutivesequence/solution/zui-chang-lian-xu-xu-lie-by-leetcode-solution/
- 来源:力扣(LeetCode)
- 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。