《LeetCode之每日一题》：77.绝对差不超过限制的最长连续子数组

Posted 2021-07-03 是七喜呀！

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

• 有关题目
• • 题解

题目链接： 绝对差不超过限制的最长连续子数组

有关题目

给你一个整数数组 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 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
0 <= limit <= 10^9

题解

方法一：滑动窗口 + 有序集合

思路：
枚举每一个位置作为右端点，找到其对应的最靠左的左端点，满足区间中最大值与最小值的差不超过limit

class Solution {
public:
    int longestSubarray(vector<int>& nums, int limit) {
        multiset<int> s;
        int n = nums.size();
        int l = 0 , r = 0;
        int ret = 0;//存放结果
        while(r < n){
            s.insert(nums[r]);
            //为了方便统计当前窗口内的最大值与最小值，我们可以使用平衡树
            while(*s.rbegin() - *s.begin() > limit){
                s.erase(s.find(nums[l++]));
            }
            ret = max(ret,r - l + 1);
            r++;
        }
        return ret;
    }
};

方法二：滑动窗口 + 单调队列

思路：
我们仅需要统计当前窗口内的最大值与最小值，因此我们也可以分别使用两个单调队列解决本题。

在实际代码中，我们使用一个单调递增的队列 queMin 维护最小值，一个单调递减的队列 queMax 维护最大值。
这样我们只需要计算两个队列的队首的差值，即可知道当前窗口是否满足条件。

class Solution {
public:
    int longestSubarray(vector<int>& nums, int limit) {
        deque<int> queMax, queMin;
        int ret = 0;
        int n = nums.size();
        int l = 0, r = 0;
        while(r < n){
            while(!queMax.empty() && queMax.back() < nums[r]){//单调递减的最大值数列
                queMax.pop_back();
            }
            while(!queMin.empty() && queMin.back() > nums[r]){//单调增的最小值数列
                queMin.pop_back();
            }
            queMax.push_back(nums[r]);
            queMin.push_back(nums[r]);
            while (!queMax.empty() && !queMin.empty() && queMax.front() - queMin.front() > limit) {
            //例数组: 1 2 3 4 limit = 2
            //queMax 4
            //queMin 1 2 3 
            //left = 0
                if (nums[l] == queMin.front()) {
                    queMin.pop_front();
                }
                if (nums[l] == queMax.front()) {
                    queMax.pop_front();
                }
                l++;
            }
            ret = max(ret, r - l + 1);
            r++;
        }
        return ret;
    }
};