单调栈

什么时候用单调栈呢？

通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。

单调栈里存放的元素是什么？

单调栈里只需要存放元素的下标i就可以了，如果需要使用对应的元素，直接nums[i]就可以获取。

 

模板

 　　heights.push_back(-1);

        int n = heights.size();

        stack<int>st;

        int ans = 0;

        for(int i=0;i<n;i++){

            while(!st.empty()&&heights[i]<heights[st.top()]){

                int index = st.top();st.pop();

                int pre = st.empty()?-1:st.top();

              

                ans = max(ans,???);

            }

            st.push(i);

        }

        return ans;

 

剑指 Offer II 038. 每日温度 - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        int n = temperatures.size();
        stack<int>st;
        vector<int>ans(n,0);
        for(int i = 0;i<n;i++){
            while(!st.empty()&&temperatures[i]>temperatures[st.top()]){
                ans[st.top()] = i - st.top();
                st.pop();
            }
            st.push(i);
        }
        return ans;
    }
};

 496. 下一个更大元素 I - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        int n = nums2.size();
        vector<int> tem(n,-1);
        vector<int> ans(nums1.size(),-1);
        unordered_map<int,int>map;
        stack<int> st;
        for(int i=0;i<nums2.size();i++){
            map[nums2[i]] = i;
            while(!st.empty()&&nums2[i]>nums2[st.top()]){//st.top()是下标不能直接比！！,3,2,1,4，所以是while！
                tem[st.top()] = nums2[i];
                st.pop();
            }
            st.push(i);
        }
        for(int i=0;i<nums1.size();i++){
            // cout<<map[nums1[i]]<<" "<<tem[map[nums1[i]]]<<endl;
            ans[i] = tem[map[nums1[i]]];
        }
        return ans;
    }   
};

503. 下一个更大元素 II - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n = nums.size();
        vector<int>ans(n,-1);
        stack<int>st;
        for(int i=0;i<2*n;i++){
            while(!st.empty()&&nums[i%n]>nums[st.top()%n]){
                ans[st.top()%n] = nums[i%n];
                st.pop();
            }
            st.push(i%n);
        }
        return ans;
    }
};

 42. 接雨水 - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        int ans = 0;
        stack<int>st;
        for(int i=0;i<height.size();i++){
            while(!st.empty()&&height[i]>height[st.top()]){
                int low = height[st.top()];st.pop();
                if(st.empty())
                    break;
                int y = min(height[i],height[st.top()]) - low;
                int x = i-1-st.top();
                ans+=x*y;
            }
            st.push(i);
        }
        return ans;
    }
};

907. 子数组的最小值之和 - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
private:
    const int BASE = 1e9 + 7;
public:
    int sumSubarrayMins(vector<int>& arr) {
        stack<int> stk;
        arr.push_back(0);               // 保证栈中所有元素都会被弹出计算
        int len = arr.size();
        long res = 0;
        for ( int i = 0; i < len; ++i ) {
            while ( !stk.empty() && arr[i] <= arr[stk.top()] ) {
                int index = stk.top(); stk.pop();
                int prev_index = stk.empty()?-1:stk.top();
                int prev_count = index - prev_index - 1; // 数量m
                int next_count = i - index - 1;          // 数量n
                res += long(arr[index]) * (prev_count + 1) * (next_count + 1) % BASE;
                res %= BASE;
            }
            stk.push(i);
        }
        return res;
    }
};
/*
    数组。存下标就行，下标可以方便取到数值
    升序序列特殊情况，所以最后加0
    当前位置可以作为多少个连续子数组的最小值！左边m个数小于nums[cur]，右边n个数小于nums[cur]，1+m+n+m*n = (m+1)*(n+1)
    prepre,pre,cur。cur是当前未入栈元素，比栈顶元素小(比栈顶元素大就直接入栈),pre是弹出的栈元素，prepre是弹出栈元素之后的栈顶元素
    pre-1-prepre = m  ,   cur-1-pre = n 
*/

剑指 Offer II 039. 直方图最大矩形面积 - 力扣（LeetCode） (leetcode-cn.com)

class Solution {//思想都是，当前i位置，只是操作之前的数据，然后操作完了i位置数据入栈，等待被后续位置的数操作
public:
    int largestRectangleArea(vector<int>& heights) {//[2,1,5,6,2,3,1]最后一个1的时候，先计算了3，再计算了10，2，3,再计算1，10，2，3，只会前面那个1出栈，此时栈空，计算出下标0-5的长度，最后那个1入栈，然后此时到了我构造的-1，和之前一样先算1，然后1出栈栈空算全部
        heights.push_back(-1);//因为题目数据最小是0
        int n = heights.size();
        int ans = 0;
        stack<int> st;
        for(int i=0;i<n;i++){
            while(!st.empty()&&heights[i] < heights[st.top()]){
                int index = st.top();st.pop();//以index位置的高度为矩形高时，最大矩形的情况，
                int pre = st.empty()?-1:st.top();//栈为空表示没有数据比index的高度要低了，也就是0-index这块都可以以index为高
                int x = i-1-pre;//i-1是右边界不包括i，左边界不包括pre。要在pre右边，因为单调递增栈heights[pre]<heights[index]
                int y = heights[index];
                ans = max(ans,x*y);
            }
            st.push(i);
        }
        return ans;
    }
};
/*
    对于任意位置，找到以这个位置为高的最大面积（往左往右延申）
*/