单调队列(monotone-Queue)/单调栈(monotone-Stack)

======================= **基础知识** =======================

单调队列(monotone-Queue)：重点关注队首元素

　　目的： 主要为了解决RMQ(range Minimum/Maximum Query) 区间最值问题；

　　　　　如果不移除开头元素，则最终deque 中留下的元素，则是用来解决固定末尾RMQ问题；

　　　　　本质来讲，由每次往后移位后对应的deque , 就可以得到以当前值为结尾，任意区间范围内的最值；

　　　　　单调序列是对原序列中的另外一种信息的表现形式；

　　数据结构性质： deque(double end queue) 存储数据，用来维护滑动窗口（逻辑概念）内数据的单调性（单调递增/减），从而保证队首元素为当前区间最值；

　　　　　　　注意：队尾元素并没有任何特性；

　　　　　　　单调队列的相对位置，与原序列相同；

　　具体操作： 窗口移动过程中，如果新加入的值破坏单调性，对deque 进行 pop_back 直到新加入元素可以插入尾部，并满足单调性；

　　　　　　　　如果头部最值被移出窗口范围，pop_front 弹出数据；

　　　　　　　　入队操作： 队尾入队，把之前破坏单调性的元素从队尾移出（维护单调性）；

　　　　　　　　出队操作： 如果队首元素超出区间范围，将元素从队首出队（维护生命周期）；

 

单调栈(monotome-Stack)：重点关注每个元素存储过程中，相互关系；

　　目的：擅长维护最近【大于/小于】关系，实现检索到前面&后面中最近（第一个）大于/小于 他的元素；

　　　　下面有个比方：

　　　　所有被我打动了的，我是她们的男神；--> 我是她们后面第一个比她们最大的元素； （基于单调递减栈）

　　　　那个我打动不了的，她是我的女神。   --> 她是前面第一个比我大，或者相等的元素；(基于单调递减栈）

　　数据结构性质：单调递增： 最近小于关系；留下的值意味着后面没有比他更小的值；

　　　　　　　　   单调递减： 最近大于关系； 留下的值意味着后面没有比他更大的值；

　　　　左侧先入栈的，是维护左侧最近关系；右侧先入栈的，是维护右侧最近关系；

　　　　　　　　　　
======================= **代码演示** =======================

单调队列： 模板题 239. 滑动窗口最大值 

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ans;
        deque<int> deq;
        for(int i = 0, I = nums.size(); i < I; i++) {
            while(deq.size() && nums[deq.back()] < nums[i]) deq.pop_back();
            deq.push_back(i);
            if(deq.front() <= (i - k)) deq.pop_front();
            if((i + 1) < k) continue;
            ans.push_back(nums[deq.front()]);
        }
        return ans;
    }
};

单调栈：

//input : 10 6 7 9 0 8 3 4 5 1 2 


//#include "monotoneStack.h"
#include <iostream>
#include <vector>
#include <stack>

using namespace std;

void output(const char *msg, vector<int>& arr) {
    printf("%s", msg);
    for(auto x : arr)  printf("%5d", x);
    printf("\n");
    return;
}

int main()
{
    int n;
    cin >> n;

    vector<int> ind(n);
    vector<int> arr(n);
    stack<int> s;   //单调递增栈
    vector<int> pre(n), next(n);  //某个值的前面离他最近比他小的值（pre)，后面离他最近比他小值(next)

    for(int i = 0; i < n; i++) cin >> arr[i], ind[i] = i;
    for(int i = 0; i < n; i++) {
        while(s.size() && arr[i] < arr[s.top()]) {
            next[s.top()] = i;
            s.pop();
        }
        if(s.size() == 0) pre[i] = -1;
        else pre[i] = s.top();
        s.push(i);
    }

    while(s.size()) next[s.top()] = n, s.pop();
    
    output("ind:", ind);
    output("arr:", arr);
    output("pre:", pre);
    output("nxt:", next);

    return 0;
}

======================= **经典问题** =======================

1. 单调队列处理过程，窗口的灵活运用； 好好体会 窗口是一个逻辑概念；

　　对于单调队列，窗口可以是固定的大小，也可以是一个满足某种条件下的范围变化；

　　在单调队列每压入新元素时，队列中存在的都是基于当前元素为结尾且满足单调性的元素，并且按照下标顺序；

　　每次都有可能完全更改队列元素，但是性质一定是不变的； 而且从数值角度来讲，只要元素能一直保存下来，那后面的元素会离这个保留下来的元素越来越近；

862. 和至少为 K 的最短子数组  ： 单调队列中元素的相对位置，与原序列相同；

//original
class Solution {
public:
    int shortestSubarray(vector<int>& nums, int k) {
        int ans = nums.size() + 1;
        vector<long long> preSum(ans, 0);
        deque<int> SumInc(1, 0); 

        for(int i = 0, I = nums.size(); i < I; i++) {
            preSum[i + 1] = preSum[i] + nums[i];

            //在单调递增队列中，每轮中处理后的队列中的元素相对位置，与原序列相同；
            //对于窗口的调整，依据每轮中最大值与 front 值 > k，则可以不断尝试缩小左边窗口；
            //对于后面进入的元素，要想距离更短，必然在上一轮满足>k 条件 front 点的后面；
            while(SumInc.size() && preSum[SumInc.back()] >= preSum[i + 1]) SumInc.pop_back();
            SumInc.push_back(i + 1);
            int temp = -1;
            while(preSum[i + 1] - preSum[SumInc.front()] >= k) {
                temp = SumInc.front();
                SumInc.pop_front();
            }
            if(temp == -1) continue;
            if (ans > (i + 1 - temp)) ans = i + 1- temp;
        }
        if(ans > nums.size()) ans = -1;
        return ans;
    }
};

剑指 Offer 59 - II. 队列的最大值 ：

class MaxQueue {
public:
    vector<int> arr;
    deque<int> dq;
    int start;
    MaxQueue():start(-1) {}
    
    int max_value() {
        if(arr.size() <= start + 1) return -1;
        return arr[dq.front()];
    }
    
    void push_back(int value) {
        while(dq.size() && value >= arr[dq.back()]) dq.pop_back();
        dq.push_back(arr.size());
        arr.push_back(value);
        return;
    }
    
    int pop_front() {
        if(arr.size() <= start + 1) return -1;
        start += 1;
        if(dq.front() == start) dq.pop_front();
        return arr[start];
    }
};

/**
 * Your MaxQueue object will be instantiated and called as such:
 * MaxQueue* obj = new MaxQueue();
 * int param_1 = obj->max_value();
 * obj->push_back(value);
 * int param_3 = obj->pop_front();
 */

//origianl 
class MaxQueue {
public:
    deque<int> a, ma;

    MaxQueue():a(deque<int>{}), ma(deque<int>{}) {}
    
    int max_value() {
        if(a.empty() ) return -1;
        return ma.front();
    }
    
    void push_back(int value) {
        a.push_back(value);
        while(ma.size() && ma.last() < value) ma.pop_back();
        ma.push_back(value);
        return;
    }
    
    int pop_front() {
        if(a.empty()) return -1;
        int ret = a.front();
        if(ret == ma.front()) ma.pop_front();   //这里的判断front 出队是要想好的
        a.pop_front();
        return ret;
    }
};

/**
 * Your MaxQueue object will be instantiated and called as such:
 * MaxQueue* obj = new MaxQueue();
 * int param_1 = obj->max_value();
 * obj->push_back(value);
 * int param_3 = obj->pop_front();
 */

 1438. 绝对差不超过限制的最长连续子数组  : 与上面 862 题做对比，最短用一个优先队列就可以解决，最长必须要两个；

优先队列会不断的用后面的更紧凑的元素来取代前面元素，并保持与原始序列 相同的 相对位置；所以留下的是距离更近的元素，但是距离都会是靠后位置元素；所以 862只要一组，求最短；

每次压入新元素过程，就是一次以当前元素为末尾，获得区间最值；这时候也是窗口移动的机会；

class Solution {
public:
    int longestSubarray(vector<int>& nums, int limit) {
        deque<int> min_arr, max_arr;
        int ret = 0, l = -1, flag = 0;
        for(int i = 0, I = nums.size(); i < I; ++i) {
            while(max_arr.size() && nums[i] > nums[max_arr.back()]) max_arr.pop_back();
            while(min_arr.size() && nums[i] < nums[min_arr.back()]) min_arr.pop_back();
            max_arr.push_back(i);
            min_arr.push_back(i);
            
            //谁位置更靠前 并且不满足<limit 条件，谁弹出；
            //然后以这个弹出位置,为前置节点，寻找下一组满足条件区间；
            while(min_arr.size() && max_arr.size() && nums[max_arr.front()] - nums[min_arr.front()] > limit) {
                if(max_arr.front() < min_arr.front()) {
                    l =  max_arr.front();
                    max_arr.pop_front();
                } else {
                    l = min_arr.front();
                    min_arr.pop_front();
                }
            }

            ret = max(ret, i - l);
        }
        return ret;
    }
};

 

2. 907. 子数组的最小值之和 ： 重点在与转换题意，单调栈 与 单调队列并没有本质区别；

　　RMQ解法：以每个元素为结尾时求RMQ， 然后以该元素位置(index)向前的(index + 1)个连续子数组的最小值  对应为RMQ中元素，求和；

　　单调栈解法： 处理每个元素时候，可以得到以该元素为最小值的连续子数组的前后范围，在该范围内包含该元素的所有连续子数组个数可得，求和；

class Solution {
public:
    int sumSubarrayMins(vector<int>& arr) {
#define MOD_NUM (long long)(1e9 + 7)
//单调队列RMQ
        deque<int> dq; //单调递增
        vector<long long> sum(arr.size(), 0);
        long long ret = 0;
        for(int i = 0, I = arr.size(); i < I; ++i) {
            while(dq.size() && arr[dq.back()] > arr[i]) dq.pop_back();
            dq.push_back(i);
            
//用空间换时间,记录下前面元素和值，后面计算涉及到前面元素时候，直接用
            int pre_ind = dq.size() ? dq.back() : -1;
            if(pre_ind == -1) sum[i] = arr[i] * (i - pre_ind);
            else sum[i] = sum[pre_ind] + arr[i] * (i - pre_ind);
            ret += sum[i];
//下面增加时间复杂度
//            for(int j = dq.size() - 1; j > 0; --j) {
//                ret += (arr[dq[j]] * (dq[j] - dq[j - 1]));
//            } 
//            ret += (arr[dq[0]] * (dq[0] + 1));

        }

//单调栈
//        int len = arr.size();
//        vector<int> l(len, -1), r(len, len);
//        stack<int> s_inc; 
//        for(int i = 0; i < len; ++i) {
//            while(s_inc.size() && arr[s_inc.top()] > arr[i]) {
//                r[s_inc.top()] = i;
//                s_inc.pop();
//            }
//            if(s_inc.size()) l[i] = s_inc.top();
//            s_inc.push(i);
//        }
//        long long ret = 0;
//        for(int i = 0; i < len; ++i) {
//            int pre = i - l[i] - 1, nxt = r[i] - i - 1;
//            ret += (long long)arr[i] * (long long)(pre + nxt + 1 + pre * nxt);
//        }
//
        return ret % MOD_NUM;
    }
};

 

1499. 满足不等式的最大值 : 增加对于push/pop 的额外条件限制；

class Solution {
public:
    int findMaxValueOfEquation(vector<vector<int>>& points, int k) {
        deque<vector<int>> dq_dec; 
        int ans = INT_MIN;

        for(int i = 0, I = points.size(); i < I; ++i) {
            while(dq_dec.size() && (points[i][0] - dq_dec.front()[0] > k)) dq_dec.pop_front();
            if(dq_dec.size()) ans = max(ans, points[i][0] + points[i][1] + dq_dec.front()[1] - dq_dec.front()[0]);
            while(dq_dec.size() && (dq_dec.back()[1] - dq_dec.back()[0] < points[i][1] - points[i][0])) dq_dec.pop_back(); 
            dq_dec.push_back(points[i]);
        }
        return ans;
    }
};

  

3. 单调栈：求解元素的最近的大于/小于关系时候，才使用单调栈；

 　　503. 下一个更大元素 II : 单调栈模板题，体会下被打动的，我都是她们的男神； 单调递减栈，对于被弹出元素， 我是在她们后面第一个大于她的；

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        //单调递减
        stack<int> sd;
        vector<int> ans(nums.size(), -1);
        for(int i = 0, I = nums.size(); i < I; ++i) {
            while(sd.size() && nums[sd.top()] < nums[i]) {
                ans[sd.top()] = nums[i];
                sd.pop();
            }
            sd.push(i);
        }

        for(int i = 0, I = nums.size(); i < I; ++i) {
            while(sd.size() && nums[sd.top()] < nums[i]) {
                ans[sd.top()] = nums[i];
                sd.pop();
            }
            sd.push(i);
        }
        return ans;
    }
};

　　901. 股票价格跨度  ： 单调栈模板题： 体会下打动不了的，她是我女神；　单调递减栈，对于当前压入元素，前面元素第一个大于等于我的；

class StockSpanner {
public:
    stack<int> s_dec ;
    vector<int> nums;
    StockSpanner() {}
    
    int next(int price) {
        while(s_dec.size() && nums[s_dec.top()] <= price) s_dec.pop();
        nums.push_back(price);
        int ret = nums.size();
        if(s_dec.size()) ret = nums.size() - 1 - s_dec.top(); 
        s_dec.push(nums.size() - 1);
        return ret;
    }
};

/**
 * Your StockSpanner object will be instantiated and called as such:
 * StockSpanner* obj = new StockSpanner();
 * int param_1 = obj->next(price);
 */

 

4. 综合利用单调栈性质： 难点在分析题目需求，以及一些题目中对于相等元素的取舍；

　　84. 柱状图中最大的矩形  ： 需要同时记录前后的第一个小于元素；

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        vector<int> pre(heights.size(), -1), nxt(heights.size(), heights.size());
        stack<int> s_inc;
        for(int i = 0, I = heights.size(); i < I; ++i) {
            while(s_inc.size() && heights[s_inc.top()] > heights[i]) {
                nxt[s_inc.top()] = i;
                s_inc.pop();
            }
            if(s_inc.size()) pre[i] = s_inc.top();
            s_inc.push(i);
        }
        int ret = 0;
        for(int i = 0, I = heights.size(); i < I; ++i) {
            ret = max(ret, heights[i] * (nxt[i] - pre[i] - 1));
        }
        return ret;
    }
};

 

 5. 456. 132 模式   :  重点在与如何获取：元素后面小于它的最大值

class Solution {
public:
    bool find132pattern(vector<int>& nums) {
        //132 pattern : 对于3 来讲，要求得前面小于它的最小值， 后面小于它的最大值; 然后对比后面值 是否大于 前面值
        // 这里希望1 尽可能小，32 尽可能大，并接近
        int len = nums.size();
        //前面小于它的最小值，没有就为极限值，保证后面没有大于它
        vector<int> preMin(len, 1e9);
        for(int i = 1; i < len; ++i) preMin[i] = min(preMin[i - 1], nums[i - 1]);
        
        //后面比它小的元素中最大值 
        //倒序求，到达当前元素时后面元素已经计算结束了；  //解题技巧！
        //如果当前元素后面有大于它的元素，求当前元素 到 离它最近的大于它的元素中间 最接近它的且小于它的元素;
        //因为如果 n + i 都不满足条件，n 元素 + (n + i) 后的元素 就更不可能满足条件
        stack<int> s_dec;
        for(int i = len - 1; i > 0 ; --i) {
            int close_i_val = nums[i];
            while(s_dec.size() && nums[i] > s_dec.top()) {
                close_i_val = s_dec.top();
                s_dec.pop();
            }
            if(close_i_val < nums[i] && preMin[i] < close_i_val) return true;
            s_dec.push(nums[i]);
        }

        return false;
    }
};

 

6.  42. 接雨水 : 分层求解

class Solution {
public:
    int trap(vector<int>& height) {
        int len = height.size();
        stack<int> s_dec;
//        vector<int> pre(len, -1), nxt(len, -1);
        int ret = 0;

        for(int i = 0; i < len; ++i) {
            while(s_dec.size() && height[s_dec.top()] < height[i]) {
//                nxt[s_dec.top()] = i;
                int cur_h = height[s_dec.top()];
                s_dec.pop();
                if(s_dec.empty())  continue;
                ret += (min(height[i], height[s_dec.top()]) - cur_h) * (i - s_dec.top() - 1);
            }
//            if(s_dec.size()) pre[i] = s_dec.top();
            s_dec.push(i);
        }
// 将下面直接移动到每个元素压入栈的过程中
//        for(int i = 0; i < len; ++i) {
//            if(pre[i] == -1 || nxt[i] == -1) continue;
//            int min_h = min(height[pre[i]], height[nxt[i]]);
//            ret += ((min_h - height[i]) * (i - pre[i]));
//            height[i] = min_h;
//        }
        return ret;
    }
};

 

7. 402. 移掉 K 位数字 : 使用其他数据结构 模拟单调栈的性质；

class Solution {
public:
    string removeKdigits(string num, int k) {
        if(num.size() <= k) return "0";
        string s_inc;
        int idx = 0;
        for(; num[idx] && k; ++idx) {
            while(s_inc.size() && s_inc.back() > num[idx] && k) {
                s_inc.pop_back();
                k--;
            }
            s_inc += num[idx];
        }

        if(idx == num.size()) while(k--) s_inc.pop_back();
        else s_inc += num.substr(idx);

        idx = 0;
        while('0' == s_inc[idx] && idx < s_inc.size()) idx++;
        if(idx == s_inc.size()) return "0";
        return s_inc.substr(idx);



//思路ok, 直接用string 模拟单调栈
//        if(num.size() <= k) return "0";
//        string ans = "";
//
//        stack<char> s_inc;
//        int idx = 0;
//        for(; num[idx] && k; ++idx) {
//            while(s_inc.size() && s_inc.top() > num[idx] && k) {
//                s_inc.pop();
//                k--;
//            }
//            s_inc.push(num[idx]);
//        }
//
//        if(idx == num.size()) {
//            while(k--) s_inc.pop();
//        } else ans = num.substr(idx);
//
//        while(s_inc.size()) {
//            ans = s_inc.top() + ans;
//            s_inc.pop();
//        }
//        idx = 0;
//        while('0' == ans[idx] && idx < ans.size()) idx++;
//        if(idx == ans.size()) return "0";
//        return ans.substr(idx);
    }
};

 

8.  316. 去除重复字母 :  增加进出条件；

class Solution {
public:
    string removeDuplicateLetters(string s) {
        string ret, ans;     //递增栈，结果
        unordered_map<char,int> cnt;    //记录数目，如果已经确定位置就为0

        for(auto x : s)  cnt[x]++;
        for(auto x : s) {
            if(!cnt[x]) continue;
            while(ret.size() && x <= ret.back()) {
                if(cnt[ret.back()] != 1) {
                    cnt[ret.back()]--;
                    ret.pop_back();
                } else {
                    for(auto y : ret) cnt[y] = 0;
                    ans += ret;
                    ret = "";
                }
            }
            ret.push_back(x);
        } 
        ans += ret;
        return ans;

    }
};

 

9.　155. 最小栈 : 数据结构本质是定义一种性质的，数据结构封装过程中要维护好性质，利用这一性质来解决问题；

　　下面定义的数据结构就是为了针对题目的定义的性质，不是单调栈数据结构；

class MinStack {
public:
    /** initialize your data structure here. */
    stack<int> s, s_min;
    MinStack() {

    }
    
    void push(int val) {
        s.push(val);
        //求最小值，那么要想办法留下最小值，并在下面该pop 时候pop;
        //这是这个MinStack 要维护的性质；
        if(s_min.empty() || s_min.top() >= val) s_min.push(val);
        return;
    }
    
    void pop() {
        if(s_min.top() == s.top()) s_min.pop();
        s.pop();
        return;
    }
    
    int top() {
        return s.top();
    }
    
    int getMin() {
        return s_min.top();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

 

======================= **应用场景** =======================