Leetcode：84. Largest Rectangle in Histogram（面积最大的长方形）

理解问题：首先，理解直方图的表示和问题的要求，即找到一个面积最大的长方形。
初始化：创建一个单调栈，用于存储直方图索引的单调递增或递减序列。
遍历直方图：从左到右遍历直方图的每个柱子，对于每个柱子的高度，执行以下操作：
- 如果栈为空或者当前柱子的高度大于栈顶柱子的高度，将当前索引压入栈中。
- 如果当前柱子的高度小于栈顶柱子的高度，这意味着我们找到了一个局部最小值，可以计算以这个局部最小值为左边界或右边界的长方形的面积。
计算面积：当栈不为空且当前柱子的高度小于栈顶柱子的高度时，执行以下步骤：
- 弹出栈顶元素，这代表了以弹出元素为右边界的长方形的右边界。
- 计算以弹出元素为右边界的长方形的面积，宽度是当前索引与栈顶元素索引的差值，高度是弹出元素的高度。
- 更新最大面积。
处理边界情况：遍历结束后，栈中可能还有元素，这些元素代表的是没有被完全弹出的长方形。对于栈中的每个元素，以直方图的最后一个索引作为右边界，重复上述面积计算过程。
返回结果：返回计算得到的最大面积。

这个问题的关键在于理解如何使用单调栈来处理直方图的边界情况，以及如何计算以局部最小值为边界的长方形的面积。通过这种方法，可以在 O(n) 的时间复杂度内解决这个问题。

解题思路：

对于这个题目，我首先想到的是动态规划，但是通过一番思考发现动态规划并不好做，直接利用循环和栈就能解决该问题，下面是思路：

1. 定义一个栈，利用它先进后出的思想，存储下标的位置

2.然后循环遍历数组，最后得到数组的最大面积

java实现方法1:

   /**
     * 计算数组最大面积
     *
     * @param heights 高度数组
     * @return 面积
     */
    public int largestRectangleHistogram(int[] heights) {
        if (heights == null || heights.length < 1) {
            return 0;
        }
        Deque<Integer> stack = new LinkedList<>();
        int maxArea = 0;
        int index = 0;
        // 当下标小于数组的长度,保存所有元素都进入栈中
        while (index <= heights.length) {
            if (stack.isEmpty() || (index < heights.length && heights[index] >= heights[stack.peek()])) {
                stack.push(index);
                index++;
            } else {
                int oldIndex = stack.pop();
                // 当所有元素都出栈时候，宽度就为index
                int width = stack.isEmpty() ? index : index - stack.peek() - 1;
                // 获取面积最大（宽度*高度）
                maxArea = Math.max(maxArea, width * heights[oldIndex]);
            }
        }
        return maxArea;
    }

时间复杂度：O(n)

空间复杂度：O(n)

python实现方式1：

from typing import List


def largest_rectangle_histogram(heights: List[int]) -> int:
    '''
        计算最大矩形长度
    Args:
        heights: 数组长度
    Returns:
        矩形最大面积
    '''
    if heights == None or len(heights) < 1:
        return 0
    stack = []
    max_area = 0
    index = 0
    while index < len(heights):
        if len(stack) < 1 or (index < len(heights) and heights[index] >= heights[stack[-1]]):
            stack.append(index)
            index += 1
        else:
            top = stack.pop()
            width = index if len(stack) < 1 else index - stack[-1] - 1
            max_area = max(max_area, width * heights[top])
    return max_area

时间复杂度：O(n)

空间复杂度：O(n)

java实现方法2:

   /**
     * 计算数组最大面积（brute force）
     *
     * @param heights 高度数组
     * @return 面积
     */
    public int largestRectangleHistogram2(int[] heights) {
        int area = 0, n = heights.length;
        // 遍历每个柱子，以当前柱子的高度作为矩形的高 h，
        // 从当前柱子向左右遍历，找到矩形的宽度 w。
        for (int i = 0; i < n; i++) {
            int w = 1, h = heights[i], j = i;
            while (--j >= 0 && heights[j] >= h) {
                w++;
            }
            j = i;
            while (++j < n && heights[j] >= h) {
                w++;
            }
            area = Math.max(area, w * h);
        }
        return area;
    }

时间复杂度：O(n^2)

空间复杂度：O(1)

python实现方法2:

def largest_rectangle_histogram2(heights: List[int]) -> int:
    '''
        计算最大矩形长度
    Args:
        heights: 数组长度
    Returns:
        矩形最大面积
    '''
    if not heights:
        return 0
    if len(heights) < 2:
        return heights[0]
    area_max = 0
    for i in range(len(heights)):
        height = heights[i]
        width = 1  # 当前宽度为1
        k = i - 1
        while k >= 0 and heights[k] >= height:
            width += 1
            k -= 1
        k = i + 1
        while k <= len(heights) - 1 and heights[k] >= height:
            width += 1
            k += 1
        area_max = max(area_max, height * width)
    return area_max

时间复杂度：O(n^2)

空间复杂度：O(1)