[LeetCode]84. 柱状图中最大的矩形

题目

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

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

以上是柱状图的示例，其中每个柱子的宽度为 1，给定的高度为 [2,1,5,6,2,3]。

图中阴影部分为所能勾勒出的最大矩形面积，其面积为 10 个单位。

示例:

输入: [2,1,5,6,2,3]
输出: 10

解题思路

解法一：暴力法

枚举以每个柱形为高度的最大矩形的面积。具体来说就是：依次遍历柱形的高度，对于每一个柱形高度分别向两边扩散，求出以当前高度为矩形的最大宽度是多少，即：
1）向左看最多能向左延伸多长，找到其左侧第一个高度小于当前柱形高度的柱子下标；
2）向右看最多能向右延伸多长；找到其右侧第一个高度小于当前柱形高度的柱子下标。
对于每一个位置，我们都这样计算一遍，这样这两根柱子之间（不包括其本身）的所有柱子高度均不小于当前柱形高度，也就是当前柱形能够扩展到的最远范围，然后计算以当前柱子作为高的矩形面积，最后比较出最大的矩形面积即可。

复杂度分析：
时间复杂度：O(N^2)，这里 N 是输入数组的长度。
空间复杂度：O(1)。

解法二：单调（递增）栈

我们遍历每个柱体，若当前的柱体高度大于等于栈顶柱体的高度，就直接将当前柱体入栈，否则若当前的柱体高度小于栈顶柱体的高度，说明栈顶柱体找到了右边的第一个小于自身的柱体，那么就可以将栈顶柱体出栈来计算以其为高的矩形的面积了。

类似题目（单调递减栈）42. 接雨水

复杂度分析：
时间复杂度：O(N)，输入数组里的每一个元素入栈一次，出栈一次。
空间复杂度：O(N)，栈的空间最多为 N。

代码

解法一：暴力法

注：Java代码可以通过，Python不行
Java代码如下：

class Solution {
    public int largestRectangleArea(int[] heights) {
        int len = heights.length;
        if(len == 0){
            return 0;
        }
        int res = 0;
        for(int i=0; i<len; i++){
            int curheight = heights[i];
            // 找左边最后 1 个大于等于 heights[i] 的下标
            int left = i;
            while(left>0 && heights[left-1]>=curheight){
                left--;
            }
            // 找右边最后 1 个大于等于 heights[i] 的下标
            int right = i;
            while(right<len-1 && heights[right+1]>=curheight){
                right++;
            }
            // 计算面积
            int width = right-left+1;
            res = Math.max(res, curheight*width);
        }
        return res;
    }
}

Python代码如下：

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        n = len(heights)
        res = 0
        for i in range(n):
            curheight = heights[i]
            left = i
            while left > 0 and heights[left-1] >= curheight:
                left -= 1
            right = i
            while right < n-1 and heights[right+1] >= curheight:
                right += 1
            width = right-left+1
            res = max(res, curheight*width)
        return res

解法二：单调栈

Python代码如下：

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        n = len(heights)
        if n == 0:
            return 0
        heights = [0] + heights + [0]
        # 先放入哨兵结点，在循环中就不用做非空判断
        stack = [0]
        res = 0
        for i in range(1, n+2):
            # 若当前的柱体高度大于等于栈顶柱体的高度，就直接将当前柱体入栈，
            # 否则若当前的柱体高度小于栈顶柱体的高度，说明栈顶柱体找到了右边的第一个小于自身的柱体，
            # 那么就可以将栈顶柱体出栈来计算以其为高的矩形的面积了。
            while heights[stack[-1]]>heights[i]:
                h_id = stack.pop()
                h = heights[h_id]
                w = i - stack[-1] - 1 
                res = max(res, h*w)
            stack.append(i)
        return res

Java代码如下：

class Solution {
    public int largestRectangleArea(int[] heights) {
        int len = heights.length;
        if(len == 0){
            return 0;
        }
        int res = 0;
        int[] newHeights = new int[len+2];
        for(int i=0; i<len; i++){
            newHeights[i+1] = heights[i];
        }
        len += 2;
        heights = newHeights;
        Deque<Integer> stack = new ArrayDeque<>();
        // 先放入哨兵，在循环里就不用做非空判断
        stack.addLast(0);
        for(int i=1; i<len; i++){
            while(heights[stack.peekLast()]>heights[i]){
                int h_id = stack.pollLast();
                int h = heights[h_id];
                int w = i - stack.peekLast() - 1;
                res = Math.max(res, h*w);
            }
            stack.addLast(i);
        }
        return res;
    }
}