单调队列 Monotonic Queue应用:leetcode(未完待续)

239. Sliding Window Maximum

581: https://leetcode.com/problems/shortest-unsorted-continuous-subarray/

862: https://leetcode.com/problems/shortest-subarray-with-sum-at-least-k/
496: https://leetcode.com/problems/next-greater-element-i/
84: https://leetcode.com/problems/largest-rectangle-in-histogram/

239:最主要是push

class Solution {
public:
    //单调队列：单调递增或单调递减队列
    class MQ {
            deque<pair<int,int>> mq;
            //first为数组下标。second为push该数时前面remove掉的数的个数（保持MQ中第一个元素为最大值，可能会pop掉之前的好几个元素）
            //那么，每次在front_pop时，second为0，才会pop该元素，否则，second-1（其实可以理解second为队列中总的元素数）
        public:
            void push(int val){
                //如果为空队列，直接push
                if(mq.empty()){
                    mq.push_back(make_pair(val,0));
                    return ;
                } 
                //双端队列不为空,remove掉前面小于该val的数，保证最大的为队头.
                //而且保证队列中为递减，只保留最大、次大。。。
                //3 1 在队列，现在push 2: 如何做？
                int cnt = 0;
                while(!mq.empty() && mq.back().first < val){
                    cnt = cnt + mq.back().second+1;
                    mq.pop_back();
                }
                mq.push_back(make_pair(val,cnt));
            }
            //pop的时候，pop队头，但是要保证队头元素的second属性为0.
            void pop(){
                if(!mq.empty() && mq.front().second){
                    mq.front().second--;
                    return ;
                }
                if(!mq.empty())  mq.pop_front();
            }
            int getMax(){
                return mq.front().first;
            }
    };
    
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        //每一次push,getMax,pop
        int n = nums.size();
        vector<int> res;
        deque<pair<int,int>> dq;
        MQ mq;
        for(int i=0;i<n;i++){
            mq.push(nums[i]);
            if(i >= k-1){
                res.push_back(mq.getMax());
                mq.pop();
            } 
        }
        return res;
    }
};

So we maintain a monotonic array with index increasing and value decreasing, because smaller elements like A[l] on the left are useless.

For example, with sliding window of fixed length 3,

 A = [3, 1, 4, 3, 8] => monotonic queue is like [3], [3, 1], [4], [4, 3], [8]

when element 4 enters, we remove [3, 1] because they are on the left and smaller than 4, no chance being chosen as the max element.

The head of the increasing queue is the running max!

class Solution {
public:
    //mq存nums数组下标
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        deque<int> mq;
        vector<int> res;
        int n = nums.size();
        for(int i=0;i<n;i++){
            if(!mq.empty() && i-mq.front() >=k) mq.pop_front();
            //push进去
            while(!mq.empty() && nums[mq.back()] < nums[i]){
                mq.pop_back();
            }
            mq.push_back(i);
            if(i >= k-1) res.push_back(nums[mq.front()]);
        }
        return res;
    }
};

581: 最短无序连续子数组

class Solution {
public:
    //基本方法利用排序，前后进行数组对比
    int findUnsortedSubarray(vector<int>& nums) {
        int n = nums.size();
        int res = n;
        int s=n,e=-1;
        //1 3 5 6 7 2 8 9
        //超时，优化。s:位于数组中最左边的其后有元素小于nums[s]的位置，e：位于数组最右边其前有元素大于nums[e]的位置
        // for(int i=0;i<n;i++){
        //     for(int j=i+1;j<n;j++){
        //         if(nums[i] > nums[j]) {
        //             s = i;
        //             e = j;
        //         }
        //         if(s != e){
        //             start.push_back(s);
        //             end.push_back(e);
        //         }
        //     }
        // }
        //return start.size()==0 ? 0:*max_element(end.begin(),end.end())-start.front()+1;
        //利用栈: 找出最左和左右位置。
        //当nums[j] >= 栈顶 一直push（升序），当num[j] < 栈顶开始pop直到num[j]>栈顶，此时栈顶位置为s(所有都遍历完)
        //同理：反序一遍找e
        stack<int> sta;
        for(int i=0;i<n;i++){
            while(!sta.empty() && nums[i] < nums[sta.top()]) {
                s = min(s,sta.top());
                sta.pop();
            }
            sta.push(i);
        }
        while(!sta.empty()) sta.pop();
        for(int i=n-1;i>=0;i--){
            while(!sta.empty() && nums[i] > nums[sta.top()]) {
                e = max(e,sta.top());
                sta.pop();
            }
            sta.push(i);
        }
        return s-e >n ? 0 : e-s+1;
    }
};

上述算法O(N) spce，time

优化：找出无序数组部分的最小值和最大值，再找到小于最小值的位置和大于最大值的位置(直接即为无序部分)

我们再次遍历 numsnums 数组并通过与其他元素进行比较，来找到 minmin 和 maxmax 在原数组中的正确位置。我们只需要从头开始找到第一个大于 minmin 的元素，从尾开始找到第一个小于 maxmax 的元素，它们之间就是最短无序子数组。

class Solution {
public:
    //找数组中无序部分最小与最大
    //再找到小于min的位置，大于max的位置
    int findUnsortedSubarray(vector<int>& nums) {
        int beg = -1,end = -2;
        int n = nums.size();
        int mn = INT_MAX,mx = INT_MIN;
        int flag = false;
        for(int i=1;i<n;i++){
            if(nums[i] < nums[i-1]) flag = true;
            //后面都是无序部分
            if(flag){
                if(nums[i] < mn) mn = nums[i];
            }
            
        }
        flag = false;
        for(int i=n-2;i>=0;i--){
            if(nums[i] > nums[i+1]) flag = true;
            if(flag){
                if(nums[i] > mx) mx = nums[i];
            }
        }
        //找出小于min的位置和大于max的位置，这个位置直接都无序
        int l = n,r = -1;
        for(int i=0;i<n;i++){
            if(nums[i] > mn) l = min(l,i);
            if(nums[i] < mx) r = max(r,i);
        }
        return l-r > n ? 0:r-l+1;
    }
};

862: Shortest Subarray with Sum at Least K

class Solution {
public:
    //deque+前缀和.
    //前缀和   {pre[i] <= pre[j]-K}
    int shortestSubarray(vector<int>& A, int K) {
        int n = A.size();
        int res = n+1;
        //最主要的是首先得想到前缀和:这个问题典型的前缀和
        vector<int> pre;
        int sum = 0;
        for(int i=0;i<n;i++){
            sum += A[i];
            pre.push_back(sum);
        }
        //问题转化为:pre[j]-pre[i] >= K.即对于当前的pre[j]来说，找一个pre[i]最小，且距离j最近
        //左侧 最近最小的元素(单调递减序列)
        deque<int> dq;
        for(int i=0;i<n;i++){
            if(pre[i] >= K) res = min(res,i+1);
            //首先进行结果判断
            while(!dq.empty() && pre[i]-pre[dq.front()]>=K){
                res = min(res,i-dq.front());
                dq.pop_front();
            }
            //将当前pre[i] 入队尾,尾部比当前pre[i]大的元素无机会再留在队列内le
            while(!dq.empty() && pre[i] <= pre[dq.back()]){
                dq.pop_back();
            }
            dq.push_back(i);
        }
        return res == n+1 ? -1:res;
    }
};

496: