单调栈_hard_84_柱状图中最大的矩形

题目描述

思路

方法一：递归 – 超时 Time：O(n^2)

• 在数组[0, len(heights)] 找到最小值，假设下标为index，然后计算以该最小值为高度的，左右最大扩展为宽度的面积
• 然后 递归左右两边[0, index-1]， [index+1, len(heights)]
• $TimeO(n^2)$ – 超时

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        def dfs(low, hig):
            if low > hig: return 
            elif low == hig:
                self.res = max(self.res, heights[low])
                return
            min_data, min_index = heights[low], low
            for i in range(low+1, hig+1):
                if heights[i] < min_data:
                    min_data = heights[i]
                    min_index = i
            self.res = max(self.res, (hig-low+1)*min_data)
            if min_index > low:
                dfs(low, min_index-1)
            if min_index < hig:
                dfs(min_index+1, hig)
        
        self.res = 0
        dfs(0, len(heights)-1)
        return self.res

方法二：单调栈

• Reference

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        if not heights: return 0
        stack = [0]  # 存下标
        res = 0
        for i in range(1, len(heights)):
            # print(stack)
            if not stack or heights[i] >= heights[stack[-1]]:
                stack.append(i)
            else:
                while stack and heights[stack[-1]] > heights[i]:
                    top = stack.pop()
                    if not stack:  # 栈空
                        res = max(res, i*heights[top])
                    else:# stack[-1]和i 分别为小于heights[top]的最早出现的左右下标
                        res = max(res, (i-stack[-1]-1)*heights[top])  
                stack.append(i)
        while stack:
            top = stack.pop()
            if not stack:  # 栈空
                res = max(res, len(heights)*heights[top])
            else:
                res = max(res, (len(heights)-stack[-1]-1)*heights[top])
        return res

单调栈 + 哨兵 优化

• 开头 和 结尾 添加0元素，会少一些判断操作
• 类似的做法还有：链表中的头结点，冒泡排序

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        if not heights: return 0
        heights = [0] + heights + [0]
        stack = [0]  # 存下标
        res = 0
        for i in range(1, len(heights)):
            if heights[i] >= heights[stack[-1]]:
                stack.append(i)
            else:
                while heights[stack[-1]] > heights[i]:
                    top = stack.pop()
                    # stack[-1]和i 分别为小于heights[top]的最早出现的左右下标
                    res = max(res, (i-stack[-1]-1)*heights[top])  
                stack.append(i)
        # print(stack)  # 最后栈stack剩的元素都是值为0的元素
        return res

• $Time:O(n)$
• $Space:O(n)$