单调栈5道题

1.Leetcode739. 每日温度

单调栈O(n)
栈存储下标
当下一个值小于等于前一个值时存入栈中，直到遇到当前值大于前一个值，将小于的都弹出，那么弹出的值右边最大值当然是当前值

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

2. Leetcode496. 下一个更大元素 I

这里为什么对num2使用单调栈，但是num1还可以找到下一个最大值呢，主要是num2包括num1，而且两个数组都不重复，那么就可以通过值映射找到num1下标了

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
          vector<int>ans(nums1.size(),-1);
          unordered_map<int,int>umap;
          stack<int>st;

          for(int i=0;i<nums1.size();i++){
              umap[nums1[i]]=i;
          }
          for(int i=0;i<nums2.size();i++){
              while(!st.empty()&&nums2[i]>nums2[st.top()]){
                //这里注意nums2值的范围>nums1,可能不能在umap中查到
                if(umap.count(nums2[st.top()])>0){
                    ans[umap[nums2[st.top()]]]=nums2[i];    
                }
                st.pop();
              }
              st.push(i);
          }
          return ans;

    }
};

3.LeetCode503. 下一个更大元素 II

表面是循环其实开两倍大就够了，保证后面的数后面有之前前面的数

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
         int len=nums.size();
         vector<int>ans(len,-1);
         vector<int>nums1(nums.begin(),nums.end());
         nums.insert(nums.end(),nums1.begin(),nums1.end());
         stack<int>st;

         for(int i=0;i<len*2-1;i++){
             while(!st.empty()&&nums[i]>nums[st.top()]){
                 if(st.top()<len)ans[st.top()]=nums[i];
                 st.pop();
             }
             st.push(i);
         }
         return ans;

    }
};

4.Leetcode42. 接雨水

法一：双指针法
时间复杂度O(N² ) 超时
找两边最大值
横扫

class Solution {
public:
    int trap(vector<int>& height) { 
       int ans=0;
       for(int i=1;i<height.size()-1;i++){
           int maxl=0,maxr=0;
           for(int l=i-1;l>=0;l--){
               maxl=max(maxl,height[l]);
           }
           for(int r=i+1;r<height.size();r++){
               maxr=max(maxr,height[r]);
           }
           int h=min(maxr,maxl);
           if(h>height[i])ans+=h-height[i];
           
       }
       return ans;
    }
};

法二：动态规划解法
存取两边最大值
横扫

class Solution {
public:
    int trap(vector<int>& height) {
       vector<int>l(height.size(),0);
       vector<int>r(height.size(),0);
       int ans=0;
       l[0]=height[0];
       r[height.size()-1]=height[height.size()-1];

       for(int i=1;i<height.size();i++){
           l[i]=max(l[i-1],height[i]);
       }
       for(int i=height.size()-2;i>=0;i--){
           r[i]=max(r[i+1],height[i]);
       }
       for(int i=1;i<height.size()-1;i++){
           int h=min(l[i-1],r[i+1]);
           if(h>height[i])ans+=h-height[i];
       }
       return ans;
    }
};

法三：单调栈法：

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

      
    }
};

5.Leetcode84. 柱状图中最大的矩形

当柱子覆盖第i个矩形,如果两边大于等于这个矩形，就可以向两边拓宽，
小于的话就不可以了

法一：双指针
找i两边第一个低于i的值，r-l就是宽了，高是height[i],
时间复杂度O(n² ) 超时了，就不写了

法二：动态规划

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        //记录每一个每一个柱子左边，右边第一个小于该柱子的下标
        vector<int>l(heights.size(),0);
        vector<int>r(heights.size(),0);
        l[0]=-1;
        int ans=0;
        for(int i=1;i<heights.size();i++){
            int t=i-1;
            while(t>=0&&heights[t]>=heights[i])t=l[t];
            l[i]=t;
        }
        r[heights.size()-1]=heights.size();
        for(int i=heights.size()-2;i>=0;i--){
            int t=i+1;
            while(t<heights.size()&&heights[t]>=heights[i])t=r[t];
            r[i]=t;
        }
        for(int i=0;i<heights.size();i++){
            int w=r[i]-l[i]-1;
            if(w>0)ans=max(heights[i]*w,ans);
        }
        return ans;
    }
};

法三：单调栈

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int ans=0;
        stack<int>st;
        //最边缘的两个需要算在内所以加入两个更小的,同时可以防止访问空栈
        heights.insert(heights.begin(), 0); // 数组头部加入元素0
        heights.push_back(0); // 数组尾部加入元素0
      
        for(int i=0;i<heights.size();i++){
            while(!st.empty()&&heights[i]<heights[st.top()]){
                int mid=st.top();
                st.pop(); 
                int w=i-st.top()-1;
                ans=max(ans,w*heights[mid]);        
            }
            st.push(i);
        }
        return ans;

    }
};