84. 柱状图中最大的矩形

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/largest-rectangle-in-histogram
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1.暴力解法

public int largestRectangleArea(int[] heights) {
        int len = heights.length;

        int area = 0;
        if (len == 0) {
            return 0;
        }
        if (len == 1) {
            return heights[0];
        }
        //右扩展
        for (int i = 0; i < len; i++) {
            int widt = 1;
            for (int j = i + 1; j < len; j++) {
                if (heights[i] <= heights[j]) {
                    widt += 1;
                } else {
                    break;
                }
            }
            //左扩展
            for (int j = i - 1; j >= 0; j--) {
                if (heights[i] <= heights[j]) {
                    widt += 1;
                } else {
                    break;
                }
            }
            //计算面积
            area = Math.max(area, widt * heights[i]);
        }
        return area;
    }

2.单调栈+哨兵
单调栈

• 单调栈分为单调递增栈和单调递减栈

  • 单调递增栈即栈内元素保持单调递增的栈
  • 同理单调递减栈即栈内元素保持单调递减的栈

• 操作规则（下面都以单调递增栈为例）

  • 如果新的元素比栈顶元素大，就入栈
  • 如果新的元素较小，那就一直把栈内元素弹出来，直到栈顶比新元素小

• 加入这样一个规则之后，会有什么效果

  • 栈内的元素是递增的
  • 当元素出栈时，说明这个新元素是出栈元素向后找第一个比其小的元素

哨兵：在头尾加0，省去栈顶为0的情况
大致思路：
维护一个单调栈，栈中总是保存递增元素的索引，当遇到比栈顶元素小的元素时，将栈顶元素依次出栈，每次都计算出栈的元素能围成的最大面积，直到栈顶元素小于当前元素就停止出栈，再次进栈。

public int largestRectangleArea(int[] heights) {
        int len = heights.length;
        if (len == 0) {
            return 0;
        }
        if (len == 1) {
            return heights[0];
        }

        int area = 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);

//        System.out.println(heights[stack.peekLast()]);

        for (int i = 1; i < len; i++) {
            //栈里是下标
            while (heights[stack.peekLast()] > heights[i]) {
            //出栈的同时记录高
                int height = heights[stack.removeLast()];
                //计算宽，宽=当前下标-新栈顶下标-1
                int width  = i - stack.peekLast() - 1;
                //计算面积，比较保留最大面积
                area = Math.max(area, width * height);
            }
            将数组元素的下标压进栈
            stack.addLast(i);
        }
        return area;
    }