单调栈模板

单调栈用来求下一个元素
求大于当前元素的值中的最小值，维护一个从栈底到栈顶的单调递减的栈
求小于当前元素的值中的最大值，维护一个从栈底到栈顶的单调递增的栈
左右？
找左边就顺序遍历
找右边就逆序遍历
可以看看代码随想录的单调栈专题，把那几道敲了，就大概知道了。我的理解是单调栈主要“解决下一个元素”类的问题，像左/右边比当前元素大/小的元素里的最小/大值，这种是最直接的单调栈能解决的。单调栈，顾名思义，首先是一个栈，其次栈里的元素是单调的，即从栈底到栈顶是单调递增或递减（代码随想录是按栈顶到栈底说的）。那么在确定是单调栈能解决的问题后，第一步，就要确定栈是递增还是递减，这取决于要求的是＞当前元素的最大值还是最小值；第二步要确定遍历元素的顺序，求＞/＜当前元素左边的元素最小/大值，就要从左到右遍历，求＞/＜当前元素右边的最小/大值，就从右到左遍历，即左边还是右边决定遍历顺序。以求数组中元素的左边大于当前的元素为例，求的是大于的元素，那么单调栈从栈底到栈顶的顺序为单调递减的，即大->小，栈顶的元素小于当前元素等于就出栈，直到大于当前元素停止，此时计下当前栈顶元素（栈里放的是元素下标，所以很好记下元素），然后当前元素入栈，再继续下一个元素。而像接雨水这种，找的还是当前元素的左边大于当前值的最小值外，但是出栈的时候还要处理。而像今天的每日一题，找的是连续子数组的最小值的和，考虑每一个元素能作为最小值的连续子数组个数，就需要找到当前元素左边大于它的最小值的下标，和右边大于它的最小值下标，所以用单调栈，而且是从栈底到栈顶递减的单调栈，又左右都要找，所以顺序找左边，逆序找右边，但从栈底到栈顶元素都是递减。这样就找到了当前元素是最小值的最大范围，在这个范围里左边能取的下标的个数右边能取的下标的个数当前元素值，就是这个元素对结果的贡献，每一个元素的贡献加起来就是结果。希望对你有一点点帮助，因为是个人的一点点理解，可能有理解不到位的地方，还请见谅。
2104子数组范围和

class Solution {
public:
    long long subArrayRanges(vector<int>& nums) {
        int n = nums.size();
        //考虑nums[i], 其对结果的贡献为：nums[i]*m-nums[i]*n;其中m表示nums[i]是m个空间的最大值，n表示nums[i]是n个空间的最小值
        //求m, n,即是求大于nums[i]的最左右小值，小于nums[i]的最左右大值
        vector<int> leftMin(n);
        vector<int> rightMin(n);
        vector<int> leftMax(n);
        vector<int> rightMax(n);
        stack<int> l;
        stack<int> r;
        //求nums[i]作为最大值的最左范围，维护一个从栈底到栈顶的单调递减的栈
        for(int i=0; i<n; ++i){
            while(!l.empty() && nums[l.top()]<nums[i]){
                l.pop();
            }
            if(l.empty()){
                leftMin[i] = -1;
            }else{
                leftMin[i] = l.top();
            }
            //cout<<"i:"<<i<<"leftMin:"<<leftMin[i]<<endl;
            l.push(i);
        }
        //求nums[i]作为最大值的最右范围，维护一个从栈底到栈顶的单调递减的栈
        for(int i=n-1; i>=0; --i){
            while(!r.empty() && nums[r.top()]<=nums[i]){
                r.pop();
            }
            if(r.empty()){
                rightMin[i]=n;
            }else{
                rightMin[i]=r.top();
            }
            //cout<<"i:"<<i<<"rightMin:"<<rightMin[i]<<endl;
            r.push(i);
        }
        while(!l.empty()) l.pop();
        while(!r.empty()) r.pop();
        //求nums[i]作为最小值的最左范围，维护一个从栈底到栈顶的单调递增的栈
        for(int i=0; i<n; ++i){
            while(!l.empty() && nums[l.top()]>nums[i]){
                cout<<l.top()<<endl;
                l.pop();
            }
            if(l.empty()){
                leftMax[i] = -1;
            }else{
                leftMax[i] = l.top();
            }
            //cout<<"i:"<<i<<"leftMax:"<<leftMax[i]<<endl;
            l.push(i);
        }
        //求nums[i]作为最小值的最右范围，维护一个从栈底到栈顶的单调递增的栈
        for(int i=n-1; i>=0; --i){
            while(!r.empty() && nums[r.top()]>=nums[i]){
                r.pop();
            }
            if(r.empty()){
                rightMax[i]=n;
            }else{
                rightMax[i]=r.top();
            }
            //cout<<"i:"<<i<<"rightMax:"<<rightMax[i]<<endl;
            r.push(i);
        }
        long long res=0;
        for(int i=0; i<n; ++i){
            long long m = (i-leftMin[i])*(rightMin[i]-i);
            long long n = (i-leftMax[i])*(rightMax[i]-i);
            res += (m-n)*nums[i]; 
        }

        return res;

更简洁写法，参考如下：

907子数组的最小值之和

class Solution {
    private static final int MOD = 1000000007;

    // 重写根据下标取值方法，-1和n返回MIN_VALUE
    private int getElement(int[] arr, int n, int i) {
        if (i == -1 || i == n) {
            return Integer.MIN_VALUE;
        }
        return arr[i];
    }
    
    public int sumSubarrayMins(int[] arr) {
        // 处理边界情况
        if (arr == null || arr.length == 0) {
            return 0;
        }
        int n = arr.length;
        long ans = 0;
        Deque<Integer> stack = new LinkedList<>();
        // 将下标-1和n作为两个哨兵元素，它们对应的元素为MIN_VALUE
        // -1作为最左边界，n作为最右边界
        for (int i = -1; i <= n; i++) {
            // 向左寻找第一个小于等于A[i]的元素
            while (!stack.isEmpty() && getElement(arr, n, stack.peek()) > getElement(arr, n, i)) {
                // A[cur]就是之前思路中的A[i]，注意区分和上面代码的区别
                // 对于每个出栈元素来说，i就是它们的右边界，而栈顶元素就是左边界
                int cur = stack.pop();
                // 计算贡献值
                ans = (ans + (long)(cur - stack.peek()) * (i - cur) * arr[cur]) % MOD;
            }
            stack.push(i);
        }

        return (int)ans;
    }
}

作者：yimeixiaobai
链接：https://leetcode.cn/problems/sum-of-subarray-minimums/solution/xiao-bai-lang-dong-hua-xiang-jie-bao-zhe-489q/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。