leetcode--绝对差不超过限制的最长连续子数组

 题目是LeetCode第187场周赛的第三题，链接：绝对差不超过限制的最长连续子数组。具体描述为：给你一个整数数组 nums ，和一个表示限制的整数 limit，请你返回最长连续子数组的长度，该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。如果不存在满足条件的子数组，则返回 0 。

 示例1:

输入：nums = [8,2,4,7], limit = 4
输出：2 
解释：所有子数组如下：
[8] 最大绝对差 |8-8| = 0 <= 4.
[8,2] 最大绝对差 |8-2| = 6 > 4. 
[8,2,4] 最大绝对差 |8-2| = 6 > 4.
[8,2,4,7] 最大绝对差 |8-2| = 6 > 4.
[2] 最大绝对差 |2-2| = 0 <= 4.
[2,4] 最大绝对差 |2-4| = 2 <= 4.
[2,4,7] 最大绝对差 |2-7| = 5 > 4.
[4] 最大绝对差 |4-4| = 0 <= 4.
[4,7] 最大绝对差 |4-7| = 3 <= 4.
[7] 最大绝对差 |7-7| = 0 <= 4. 
因此，满足题意的最长子数组的长度为 2 。

 示例2:

输入：nums = [10,1,2,4,7,2], limit = 5
输出：4 
解释：满足题意的最长子数组是 [2,4,7,2]，其最大绝对差 |2-7| = 5 <= 5 。

 示例3:

输入：nums = [4,2,2,2,4,4,2,2], limit = 0
输出：3

 一眼看去这道题就应该是滑动窗口+单调队列的题目，也就是用两个单调队列维护窗口内的最大值和最小值，单调队列的做法可以参考之前的博客。根据窗口内的最大最小值之差是否大于限制决定滑动窗口的变化，如果没超过限制，那就右窗口右移1位（然后需要计算窗口长度并更新最大长度），否则就看最大最小值的位置哪个在前，将左窗口移到这个位置之后就行了。每个数字最多出入队一次，因此时间复杂度为$O(n)$，空间复杂度为$O(n)$。

 JAVA版代码如下：

class Solution {
    public int longestSubarray(int[] nums, int limit) {
        // 两个单调队列分别维护从left到right之间的最大值最小值
        Deque<Integer> minDeque = new LinkedList<>();
        Deque<Integer> maxDeque = new LinkedList<>();
        int result = 0;
        int left = 0, right = 0;
        minDeque.offer(0);
        maxDeque.offer(0);
        while (right < nums.length) {
            int minIdx = minDeque.peekFirst();
            int maxIdx = maxDeque.peekFirst();
            if (nums[maxIdx] - nums[minIdx] <= limit) {
                // 最大值与最小值之差小于限制的情况下右指针右移
                result = Math.max(result, right - left + 1);
                ++right;
                // 维护两个单调队列
                while (right < nums.length && minDeque.size() > 0 && nums[right] < nums[minDeque.peekLast()]) {
                    minDeque.pollLast();
                }
                minDeque.offerLast(right);
                while (right < nums.length && maxDeque.size() > 0 && nums[right] > nums[maxDeque.peekLast()]) {
                    maxDeque.pollLast();
                }
                maxDeque.offerLast(right);
            }
            else {
                // 最大值与最小值之差大于限制的情况下左指针右移
                left = Math.min(minIdx, maxIdx) + 1;
                while (minDeque.size() > 0 && minDeque.peekFirst() < left) {
                    minDeque.pollFirst();
                }
                while (maxDeque.size() > 0 && maxDeque.peekFirst() < left) {
                    maxDeque.pollFirst();
                }
            }
        }
        return result;
    }
}

 提交结果如下:

 这里的时间貌似没那么高，那是因为题目的测试数据有点奇怪，看了一下其他时间更快的好多都是$O(n^2)$的，不过这些方法需要对于那些会超时的数据（比如全为1）做特殊判断。反正我们的方法是$O(n)$的，就不再纠结时间不够快了。

 Python版代码如下：

class Solution:
    def kLengthApart(self, nums: List[int], k: int) -> bool:
        N = len(nums)
        prev = -1
        i = 0
        while i < N:
            if nums[i] == 1:
                prev = i
                break
            i += 1
        while i < N - 1:
            i += 1
            if nums[i] == 1:
                if i - prev <= k:
                    return False
                prev = i
        return True

 提交结果如下: