【LeetCode笔记】84. 柱状图中最大的矩形（字符串、单调栈）

题目描述

• 和接雨水有点像，但是具体做法还是有点不同。
  

思路 && 代码

暴力法只能过 94 / 96 的样例：复杂度O(n^2) & O(1)，一个双重循环遍历所有可行矩阵。
这里就直接用 O(n) & O(n)的做法了（空间换时间！）

• 思路：参考了Ikaruga的题解，循环找出以某列为高的最大矩阵，再对比这些矩阵大小。
• 时间复杂度：O(n)，最多对所有元素 存储一次 + 计算一次。
• 计算值：以当前列为最高列，可行的最大矩阵（ 也就代表该矩阵【左边界，右边界】的列，都大于或等于当前列）
• 边界处理：数组前、后添加一个0，保证不会漏算
  （比如恒递增情况，不添0的话直接不计算了）

class Solution {
    public int largestRectangleArea(int[] heights) {
        int res = 0;
        // 单调栈：存储 index
        Deque<Integer> stack = new ArrayDeque<>();
        // 前后添加0：处理边界，让heights[0], heights[len - 1] 都可以参与比较（参考恒递增情况）
        int[] newHeights = new int[heights.length + 2];
        for(int i = 1; i < heights.length + 1; i++) {
            newHeights[i] = heights[i - 1];
        }
        // O(n)：遍历新数组
        for(int i = 0; i < newHeights.length; i++) {
            // 栈不为空，且当前栈顶更大（出现递减情况）时
            while(!stack.isEmpty() && newHeights[stack.peek()] > newHeights[i]) {
                int index = stack.pop(); // 用于获取当前高
                int l = stack.peek(); // 获取左边第一个比当前列矮的下标
                int r = i; // 右边第一个比当前列矮的下标
                // 计算：以stack.pop()为高，可行的最大矩形
                res = Math.max(res, (r - l - 1) * newHeights[index]);
            }
            // 加入当前下标（此时保持递增）
            stack.push(i);
        }
        return res;
    }
}

• 无注释版

class Solution {
    public int largestRectangleArea(int[] heights) {
        int res = 0;
        Deque<Integer> stack = new ArrayDeque<>();
        int[] newHeights = new int[heights.length + 2];
        for(int i = 1; i < heights.length + 1; i++) {
            newHeights[i] = heights[i - 1];
        }
        for(int i = 0; i < newHeights.length; i++) {
            while(!stack.isEmpty() && newHeights[stack.peek()] > newHeights[i]) {
                int index = stack.pop();
                int l = stack.peek();
                int r = i;
                res = Math.max(res, (r - l - 1) * newHeights[index]);
            }
            stack.push(i);
        }
        return res;
    }
}

二刷

• 单调栈，只能说 Dalao 思路还是强

class Solution {
    public int largestRectangleArea(int[] heights) {
        int[] newHeights = new int[heights.length + 2];
        for(int i = 1; i <= heights.length; i++) {
            newHeights[i] = heights[i - 1];
        }

        Deque<Integer> stack = new ArrayDeque<>();
        int max = 0;
        for(int i = 0; i < newHeights.length; i++) {
            // 当前栈顶为最高列的可行值
            while(!stack.isEmpty() && newHeights[i] < newHeights[stack.peek()]) {
                int now = stack.poll();
                int left = stack.peek(); // 左边第一个比 now 对应值小的下标
                int right = i; // 当前即是右边第一个比 now 对应值小的下标
                max = Math.max(max, (right - left - 1) * newHeights[now]); // 维护 max
            }
            // 栈中比当前大的都去掉了，now 可以加入栈，并保持单调增了。
            stack.push(i);
        }
        return max;
    }
}