【随想录】-【11 单调栈】-【05】84 柱状图中最大矩形

重点：

（1）法1：暴力解法，也称双指针。直接两个for循环，然而超时了。O(n^2)。

（2）法2：动态规划。问题的关键在于怎么抽象这个问题的解。每根柱子为高来算，找左右两边的宽度，即第一个比自己高的柱子。

（3）法3：单调栈。找左右两边第一个比自己矮的柱子。

84. 柱状图中最大的矩形

难度困难

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

示例 1:

输入：heights = [2,1,5,6,2,3]
输出：10
解释：最大的矩形为图中红色区域，面积为 10

示例 2：

输入： heights = [2,4]
输出： 4

提示：

• 1 <= heights.length <=105
• 0 <= heights[i] <= 104

解析：

方法1：双指针暴力解法

两层for循环，记录每种情况最大矩形面积。思路简单，实现简单。然而白给。

方法2：动态规划

找左右两边第一根比自己矮的柱子。然后作为宽度，高度就是当前柱子的高度。

方法3：单调栈

跟接雨水一样。接雨水是找左边两边第一根比自己高的，该题是找左右两边第一根比自己矮的。此时单调栈中元素从栈头到栈尾应该是递减的。

详见注解：代码随想录 (programmercarl.com)

代码：

//暴力解法，O(n^2)
class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        if(heights.size()==1)
            return heights[0];
        int ans=0;
        for(int i=0;i<heights.size();i++){
            if(heights[i]==0)
                continue;
            ans=max(ans,heights[i]);
            int hei=heights[i];
            for(int j=i+1;j<heights.size();j++){
                if(heights[j]==0)
                    break;
                hei=min(hei,heights[j]);
                int area=(j-i+1)*hei;
                ans=max(area,ans);
            }
        }
        return ans;
    }
};

//动态规划
class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        vector<int> minLeftIndex(heights.size());
        vector<int> minRightIndex(heights.size());
        int size = heights.size();

        // 记录每个柱子 左边第一个小于该柱子的下标
        minLeftIndex[0] = -1; // 注意这里初始化，防止下面while死循环
        for(int i = 1; i < size; i++) {
            int t = i - 1;
            // 这里不是用if，而是不断向左寻找的过程
            while (t >= 0 && heights[t] >= heights[i]) t = minLeftIndex[t];
                minLeftIndex[i] = t;
        }
        // 记录每个柱子，右边第一个小于该柱子的下标
        minRightIndex[size - 1] = size; // 注意这里初始化，防止下面while死循环
        for (int i = size - 2; i >= 0; i--){
            int t = i + 1;
            // 这里不是用if，而是不断向右寻找的过程
            while (t < size && heights[t] >= heights[i]) t = minRightIndex[t];
                minRightIndex[i] = t;
        }
        // 求和
        int result = 0;
        for (int i = 0; i < size; i++){
            int sum = heights[i] * (minRightIndex[i] - minLeftIndex[i] - 1);
            result = max(sum, result);
        }
        return result;
    }
};

//单调栈
class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        stack<int> st;
        heights.insert(heights.begin(), 0); // 数组头部加入元素0
        heights.push_back(0); // 数组尾部加入元素0
        st.push(0);
        int result = 0;
        // 第一个元素已经入栈，从下标1开始
        for (int i = 1; i < heights.size(); i++) {
            // 注意heights[i] 是和heights[st.top()] 比较 ，st.top()是下标
            if (heights[i] > heights[st.top()]) {
                st.push(i);
            } else if (heights[i] == heights[st.top()]) {
                st.pop(); // 这个可以加，可以不加，效果一样，思路不同
                st.push(i);
            } else {
                while (heights[i] < heights[st.top()]) { // 注意是while
                    int mid = st.top();
                    st.pop();
                    int left = st.top();
                    int right = i;
                    int w = right - left - 1;
                    int h = heights[mid];
                    result = max(result, w * h);
                }
                st.push(i);
            }
        }
        return result;
    }
};