Leetcode 1438. 绝对差不超过限制的最长连续子数组 （滑动窗口同时维护最大值以及最小值）

 

这道题目的是典型的滑动窗口问题，需要维护窗口里面最大值和最小值，要实现这一点，可以利用map(set不行，因为会有重的，要用

O(nlogn）的实现map

class Solution {
public:
    int longestSubarray(vector<int>& nums, int limit) {
        // 维护滑动窗口里的最大值以及最小值
        map<int,int> treemap;
        int res = 0;
        for(int i=0,j=0;i<nums.size();i++){
            while(j<nums.size()){
                treemap[nums[j]]++;
                if(treemap.rbegin()->first-treemap.begin()->first<=limit){
                    res = max(res,j-i+1);
                    j++;
                }else{
                    treemap[nums[j]]--;
                    if(treemap[nums[j]]==0) treemap.erase(nums[j]);
                    break;
                }
            }
            treemap[nums[i]]--;
            if(treemap[nums[i]]==0) treemap.erase(nums[i]);
        }
        return res;
    }
};

multiset的解法，multiset的erase方法需要特别注意。 

class Solution {
public:
    int longestSubarray(vector<int>& nums, int limit) {
        // 维护滑动窗口里的最大值以及最小值
        multiset<int> treemap;
        int res = 0;
        for(int i=0,j=0;i<nums.size();i++){
            while(j<nums.size()){
                treemap.insert(nums[j]);
                if(*treemap.rbegin()-*treemap.begin()<=limit){
                    res = max(res,j-i+1);
                    j++;
                }else{
                    treemap.erase(treemap.find(nums[j]));
                    break;
                }
            }
            treemap.erase(treemap.find(nums[i]));
        }
        return res;
    }
};

接近O(N）的做法，单调双端队列，这个做法比较难：

维护一个双端队列，使得第一个元素始终为当前滑动窗口的最大或者最小元素。需要用到单调的思想。

class Solution {
public:
    int longestSubarray(vector<int>& nums, int limit) {
        deque<int> maxDeque;
        deque<int> minDeque;   
        int res= 0; 
        for(int i=0,j=0;j<nums.size();j++){
            while(!maxDeque.empty()&&nums[j]>maxDeque.back()) maxDeque.pop_back();
            while(!minDeque.empty()&&nums[j]<minDeque.back()) minDeque.pop_back();
            maxDeque.push_back(nums[j]);
            minDeque.push_back(nums[j]);
            while(maxDeque.front()-minDeque.front()>limit){
                if(minDeque.front()==nums[i]) minDeque.pop_front();
                if(maxDeque.front()==nums[i]) maxDeque.pop_front();
                i++;
            }
            res = max(res,j-i+1);
        }
        return res;
    }
};