LeetCode84. 柱状图中最大的矩形+85. 最大矩形（单调栈）

本文链接：https://blog.csdn.net/IOT_victor/article/details/108565565

84. 柱状图中最大的矩形（单调栈）

https://leetcode-cn.com/problems/largest-rectangle-in-histogram/

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

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

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

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

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

2、代码详解

可以遍历每根柱子，以当前柱子 i 的高度作为矩形的高，那么矩形的宽度边界即为

向左找到第一个高度小于当前柱体 i 的柱体，
向右找到第一个高度小于当前柱体 i 的柱体。

对于每个柱子都如上计算一遍以当前柱子作为高的矩形面积，最终比较出最大的矩形面积即可。

方法：单调栈（保持height值是递增的）

我们每遍历到当前柱体 i 时：如何 O(1) 的获取柱体 i 左边第一个比它小的柱体吗？

答案就是单调增栈，因为对于栈中的柱体来说，栈中下一个柱体就是左边第一个高度小于自身的柱体。
遍历每个柱体，

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

stack: [] , i: 0
stack: [0] , i: 1
stack: [0, 1] , i: 2
i: 2 , temp: 1 , heights[tmp]: 2 , stack[-1]: 0 , cur_res: 2 , res: 2

stack: [0, 2] , i: 3
stack: [0, 2, 3] , i: 4
stack: [0, 2, 3, 4] , i: 5
i: 5 , temp: 4 , heights[tmp]: 6 , stack[-1]: 3 , cur_res: 6 , res: 6
i: 5 , temp: 3 , heights[tmp]: 5 , stack[-1]: 2 , cur_res: 10 , res: 10

stack: [0, 2, 5] , i: 6
stack: [0, 2, 5, 6] , i: 7
i: 7 , temp: 6 , heights[tmp]: 3 , stack[-1]: 5 , cur_res: 3 , res: 10
i: 7 , temp: 5 , heights[tmp]: 2 , stack[-1]: 2 , cur_res: 8 , res: 10
i: 7 , temp: 2 , heights[tmp]: 1 , stack[-1]: 0 , cur_res: 6 , res: 10

代码

class Solution(object):
    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        stack = []
        # 在柱体数组的头和尾加了两个高度为 0 的柱体
        heights = [0] + heights + [0]
        res = 0
        for i in range(len(heights)):
            # print('stack:', stack, ', i:', i)
            # 对栈中柱体来说，栈中的下一个柱体就是其「左边第一个小于自身的柱体」
            # 若当前柱体 i 的高度小于栈顶柱体的高度，说明 i 是栈顶柱体的「右边第一个小于栈顶柱体的柱体」
            # 因此以栈顶柱体为高的矩形的左右宽度边界就确定了，可以计算面积
            while stack and heights[stack[-1]] > heights[i]:
                tmp = stack.pop()
                res = max(res, (i - stack[-1] - 1) * heights[tmp])
                # print('i:', i, ', temp:', tmp, ', heights[tmp]:', heights[tmp], ', stack[-1]:', stack[-1],
                #       ', cur_res:', (i - stack[-1] - 1) * heights[tmp], ', res:', res)
            stack.append(i)
        return res


heights = [2, 1, 5, 6, 2, 3]  # 10
s = Solution()
print(s.largestRectangleArea(heights))

https://leetcode-cn.com/problems/largest-rectangle-in-histogram/solution/xiang-jie-dan-diao-zhan-bi-xu-miao-dong-by-sweetie/

https://leetcode-cn.com/problems/largest-rectangle-in-histogram/solution/zhao-liang-bian-di-yi-ge-xiao-yu-ta-de-zhi-by-powc/

85. 最大矩形

https://leetcode-cn.com/problems/maximal-rectangle/

给定一个仅包含 0 和 1 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。

解法一：复用84.柱状图中最大的矩形（单调栈）,逐行累加（或清零）

算法本质上和84题Largest Rectangle in Histogram一样，对每一行都求出每个元素对应的高度，这个高度就是对应的连续1的长度，然后对每一行都更新一次最大矩形面积。那么这个问题就变成了Largest Rectangle in Histogram。本质上是对矩阵中的每行，均依次执行84题算法。

class Solution(object):
    def maximalRectangle(self, matrix):
        """
        :type matrix: List[List[str]]
        :rtype: int
        """
        if len(matrix) == 0:
            return 0
        res = 0
        m, n = len(matrix), len(matrix[0])
        heights = [0] * (n+2)
        for i in range(m):
            for j in range(n):
                if matrix[i][j] == '0':
                    heights[j] = 0
                else:
                    heights[j] = heights[j] + 1
            res = max(res, self.largestRectangleArea(heights))
        return res

    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        stack = []
        # 在柱体数组的头和尾加了两个高度为 0 的柱体
        heights = [0] + heights + [0]
        res = 0
        for i in range(len(heights)):
            # 对栈中柱体来说，栈中的下一个柱体就是其「左边第一个小于自身的柱体」
            # 若当前柱体 i 的高度小于栈顶柱体的高度，说明 i 是栈顶柱体的「右边第一个小于栈顶柱体的柱体」
            # 因此以栈顶柱体为高的矩形的左右宽度边界就确定了，可以计算面积
            while stack and heights[stack[-1]] > heights[i]:
                tmp = stack.pop()
                res = max(res, (i - stack[-1] - 1) * heights[tmp])
            stack.append(i)
        return res

两函数合二为一写法（同上）

class Solution:
    def maximalRectangle(self, matrix: List[List[str]]) -> int:
        if not matrix or not matrix[0]: return 0
        row = len(matrix)
        col = len(matrix[0])
        height = [0] * (col + 2)
        res = 0
        for i in range(row):
            stack = []
            for j in range(col + 2):
                if 1<=j<=col: 
                    if matrix[i][j-1] == "1":
                        height[j] += 1
                    else:
                        height[j] = 0
                while stack and height[stack[-1]] > height[j]:
                    cur = stack.pop()
                    res = max(res, (j - stack[-1] - 1)* height[cur])
                stack.append(j)
        return res