剑指Offer|LCR 039.柱状图中最大的矩形

LCR 039.柱状图中最大的矩形

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

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

示例 1:

输入：heights = [2,1,5,6,2,3]
输出：10
解释：最大的矩形为图中红色区域，面积为 10

示例 2：

输入： heights = [2,4]
输出： 4

提示：

• 1 <= heights.length <=105
• 0 <= heights[i] <= 104

法1：暴力

**分析：**两个for循环，第一个循环i控制heights的起始位置，第二个循环i控制heights的结束位置，每次记录i-j的矩形面积，去最大的直到遍历结束。

求下标i到下标j之间的最大面积：

就是找到最小的高度，以及宽度j-i+1,相乘就是最大面积。

力扣上没法通过

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

空间复杂度：$O(1)$

 var largestRectangleArea = function(heights) {
    let result = 0;
    for (let i = 0; i < heights.length; i++) {// 开始位置
        let minHeight = Number.MAX_VALUE; // 最小高度
        for (let j = i; j < heights.length; j++) {// 结束位置
            minHeight = Math.min(minHeight, heights[j]);
            let width = j - i + 1;
            result = Math.max(minHeight * width, result);
        }
    }
    return result;
};

法2：左右指针

**分析：**遍历下标i，找到左边小于等于当前高度，找到右边小于等于当前高度，这样宽度就是右指针-左指针+1，高度就是hegihts[i]，从而计算面积，每次记录最大的面积。

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

空间复杂度：$O(1)$

 var largestRectangleArea = function(heights) {
    let maxArea = 0;
    for (let i = 0; i < heights.length; i++) {
        let left = i;
        let right = i;

        // 找到左边第一个小于 heights[i] 的位置
        while(left > 0 && heights[left - 1] >= heights[i]){
            left--;
        }
        // 找到右边第一个小于 heights[i] 的位置
        while(right < heights.length - 1 && heights[right + 1] >= heights[i]){
            right++;
        }
        let area = heights[i] * (right - left + 1);
        maxArea = Math.max(area, maxArea);
    }              
    return maxArea;
};

法3：栈

分析：

看例子heights = [2,1,5,6,2,3]

遍历新数组newHeight，下标i是结束位置，

使用while循环向左边寻找，如果当前值 小于 栈顶，就计算一下面积，比较一下找出最大面积。

时间复杂度：$O(n)$

空间复杂度：$O(n)$

var largestRectangleArea = function(heights) {
    // 创建一个新的数组，比原数组多两个元素
    let newHeight = new Array(heights.length + 2).fill(0);
    for (let i = 0; i < heights.length; i++) {
        // 将原数组heights复制到newHeight下标1开始的位置
        newHeight[i + 1] = heights[i]; 
    }

    let stack = [];
    stack.push(0); // 将第一个元素入栈

    let res = 0;
    for (let i = 1; i < newHeight.length; i++) {
        // 如果当前元素 < 栈顶元素，则开始计算矩形面积
        while(newHeight[i] < newHeight[stack[stack.length - 1]]){
            let mid = stack.pop();
            let w = i - stack[stack.length - 1] - 1; // 宽度
            let h = newHeight[mid]; //高度
            res = Math.max(res, w * h);

        }
        stack.push(i); // 将当前索引入栈
    }
    return res;
};