LeetCode单调栈总结

单调栈是一种抽象数据结构，主要用于找左/右边第一个比其大/小的元素（下标）。如何维护呢？主要还是看栈中存着的元素用来干嘛。

1.LeetCode496.下一个更大元素Ⅰ

• 这里我们需要找到右边第一大的元素，此时如果从左往右遍历每个数，维护一个数据结构时，每个元素相当于存在此数据结构里，等着右边大的数来找到它，而当右边大的数比栈顶元素大的时候，说明这个栈顶元素已经找到了右边第一个比它大的元素，那就将它pop掉，然后当前元素继续和栈顶元素比较直到空栈或者栈顶元素比其大的时候，然后再将这个元素放入栈中，等着右边的元素继续来找。
• 整个操作其实是在维护一个从栈底到栈顶递减的栈。

 int n = nums1.size();
        int lim = nums2.size();
        unordered_map<int,int> hash_map;
        stack<int> S;
        for(int i = 0; i < lim; ++i){
            while(S.size() && S.top() < nums2[i]){
                hash_map.insert(make_pair(S.top(),nums2[i]));
                S.pop();
            }
            S.push(nums2[i]);
        }

        vector<int> ans(n,-1);
        for(int i = 0; i < n; ++i){
            auto pos = hash_map.find(nums1[i]);
            if(pos == hash_map.end()) continue;
            ans[i] = pos->second;
        }
        return ans;

2.LeetCode503.下一个更大元素Ⅱ

• 仍然和上一题类似的思路，不过就是遍历两遍数组罢了。
• 有个细节就是用取mod去模拟环，然后再第二遍遍历数组的时候，就不需要push进栈了，因为第一遍遍历的时候已经做过了。

#define MP(x,y) make_pair(x,y)
class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        //10^4
        //暴力数组模拟:O(n^2)
        int n = nums.size();
        vector<int> ans(n,-1);
        stack<pair<int,int>> S;

        // for(int i = 0; i < n; ++i){
        //     while(S.size() && S.top().first < nums[i]){
        //         ans[S.top().second] = nums[i]; S.pop();
        //     }
        //     S.push(MP(nums[i],i));
        // }

        // for(int i = 0; i < n; ++i){
        //     while(S.size() && S.top().first < nums[i]){
        //         ans[S.top().second] = nums[i]; S.pop();
        //     }
        // }
        
        for(int i = 0; i < 2 * n - 1; ++i){
            while(S.size() && S.top().first < nums[i % n]){
                ans[S.top().second] = nums[i % n]; 
                S.pop();
            }
            if(i > n - 1) continue;
            S.push(MP(nums[i],i));
        }
        //效率不如直接遍历两遍：第二遍遍历的时候，就没必要再push了
        //因为单调栈里的元素储存是为了遍历的时候 让右边更大的值方便找
        return ans;
    }
};

3.LeetCode739.每日温度

• 仍然是寻找右边第一个更大的元素的下标。
• 依旧是维护一个单调栈，将元素放入栈，等右边更大的数来找，最终栈内元素是单调递减的。

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& T) {
        //以空间换时间
        int n = T.size();
        vector<int> ans(n,0);
        stack<int> S;

        for(int i = 0;i < n; ++i){
            while(S.size() && T[S.top()] < T[i]){
                ans[S.top()] = i - S.top(); S.pop();
            }
            S.push(i);
        }
        return ans;
    }
};

4.LeetCode84.柱状图中最大的矩形

• 此题关键是每根柱子找到左边第一个比其小的柱子，找到右边第一个比其小的柱子。
• 这里我都选择从左至右枚举柱子。
• 找左边第一个比其小的柱子，如何维护存储柱子的数据结构：当目前元素比栈顶元素大的时候，就是找到了。否则，一直pop栈元素，直到栈顶元素比其小，就是找到了，这些pop掉的元素都比目前元素大，不可能成为后面元素的左边第一个（因为目前元素才有可能成为）。
• 找右边第一个比其小的柱子：维护一个单调递增栈，相当于将柱子存在栈中让右边的小的元素去找它，若目前栈仍然比栈顶元素大，说明它不可能是，push入栈中；否则，栈顶元素就是找到了右边的第一小（目前柱子），然后pop掉，继续和栈顶元素比较，直到栈顶元素小于当前元素或者空栈。

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        //枚举以每个柱子为高度的 最大面积 TC >= O(n^2)
        //目标是找到每根柱子 左边第一根比它矮的下标i
        //右边第一根比它矮的下标j
        //S:h * (j - i - 1)
        //以空间换时间
        int n = heights.size();
        
        //先找每根柱子左边第一根矮的下标 存在一个数组里
        vector<int> left(n),right(n);
        stack<int> S1,S2;
        S1.push(-1);

        //维护单调递增栈；去高的 留小的,高的对后面都没用了
        for(int i = 0; i < n; ++i){
            while(S1.size() && (S1.top() != -1) && heights[S1.top()] >= heights[i])
                S1.pop();
            if(S1.size()) left[i] = S1.top();
            S1.push(i);
        }

        //找右边第一个矮的下标 ： 维护单调递增栈 去高的 留小的，因为栈里高的就是再找右边小的
        //栈里的元素 其实是先存起来 等着右边小的来找，所以栈才是单调递增的 因为这些元素右边都没出现高的
        heights.push_back(-1);
        for(int i = 0; i < heights.size(); ++i){
            while(S2.size() && heights[S2.top()] >= heights[i]){
                right[S2.top()] = i;  S2.pop();
            }
            S2.push(i);
        }
        
        int mx = 0;
        for(int i = 0; i < n; ++i){
            mx = max(mx,heights[i] * (right[i] - left[i] - 1));
        }

        return mx;
        //关键还是要想清楚栈里面的元素 存着是干嘛用的
        //在这里S1和S2的用处不一样
    }
};