84.柱状图中最大的矩形

84.柱状图中最大的矩形

84.柱状图中最大的矩形

力扣题目链接(opens new window)

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

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

• 1 <= heights.length <=10^5
• 0 <= heights[i] <= 10^4

思路:暴力算法

思路：暴力算法（双指针）
定义两个数组minLeft，minRight。分别存储heights[i]左/右侧第一个小于其元素的下标
计算矩形面积heights[i] * (minRight[i] - minLeft[i] - 1)
注意对minLeft，minRight边界初始化处理。
当i = 0时，minLeft[0] = -1;当i = heights.length - 1时，minRight[heights.length - 1] = heights.length;
为什么这样初始化呢？举例子如下：{3, 2, 5};
求下标i = 1矩形所在面积。矩形的高 = heights[1] = 2.因为3和5都比2大，所以矩形的宽为3.
minRight[i] - minLeft[i] - 1 = 3 - （-1） -1 = 3
可以得出
i = 0时，minLeft[0] = -1;
i = heights.length - 1时，minRight[heights.length - 1] = heights.length;

代码如下

public static int largestRectangleArea(int[] heights) {
    if (heights == null)
        return 0;
    int[] minLeft = new int[heights.length];// 存储heights[i]左侧第一个小于其元素的下标
    int[] minRight = new int[heights.length];// 存储heights[i]右侧第一个小于其元素的下标
    minLeft[0] = -1;
    for (int i = 1; i < heights.length; i++) {
        int t = i - 1;
        while (t >= 0) {
            if (heights[t] < heights[i]) {
                minLeft[i] = t;
                break;
            }
            t--;
        }
        if (t < 0)
            minLeft[i] = -1;

    }

    minRight[heights.length - 1] = heights.length;
    for (int i = heights.length - 2; i >= 0; i--) {
        int t = i + 1;
        while (t <= heights.length - 1) {
            if (heights[t] < heights[i]) {
                minRight[i] = t;
                break;
            }
            t++;
        }
        if (t > heights.length - 1)
            minRight[i] = heights.length;
    }

    int maxArea = 0;
    for (int i = 0; i < heights.length; i++) {
        int area = heights[i] * (minRight[i] - minLeft[i] - 1);
        if (area > maxArea)
            maxArea = area;
    }
    return maxArea;
}

优化

双指针优化
优化的思路很巧妙，暴力算法的时间复杂度为O(n^2)原因在于初始化minRight和 minLeft数组复杂度较高
可以优化初始化流程降低时间复杂度为O(n)
原因在于，尽管我们在计算每个高度的左右边界时使用了while循环，但是由于我们使用了“跳跃”的方式，每个位置最多只被访问两次。
具体来说，当我们计算一个位置的左边界时，我们从这个位置开始向左遍历，如果遇到的位置的高度大于或等于当前位置的高度，我们就跳到这个位置的左边界，因为我们知道这个位置的左边界一定也是当前位置的左边界。同样的，当我们计算一个位置的右边界时，我们从这个位置开始向右遍历，如果遇到的位置的高度大于或等于当前位置的高度，我们就跳到这个位置的右边界。
这样，每个位置最多只被访问两次，一次是自己访问，一次是作为别人的边界被访问。因此，总的时间复杂度是O(n)，其中n是高度数组的长度。这就是为什么这个算法的时间复杂度是O(n)的原因。
时间复杂度为O(n)
空间复杂度为O(n)

代码如下

for (int i = 1; i < length; i++) {
    int p = i - 1;
    while (p >= 0 && heights[p] >= heights[i]) {
        p = minLeft[p];
    }
    minLeft[i] = p;
}

minRight[length - 1] = length;
for (int i = length - 2; i >= 0; i--) {
    int p = i + 1;
    while (p < length && heights[p] >= heights[i]) {
        p = minRight[p];
    }
    minRight[i] = p;
}

思路:单调栈

单调栈
题目求柱状图中最大的矩形。首先遍历数组元素。找到数组元素左右两侧，第一个小于该数组元素的下标。
栈顶和栈顶的下一个元素以及要入栈的三个元素组成了我们要求最大面积的高度和宽度
不断遍历数组元素，更新矩形面积。找到最大面积即可。
注意
1.单调栈的顺序（栈头到栈尾）需要单调递减，才可以找到数组元素右侧，第一个小于该数组元素的下标。
2.height数组前后各加一个元素0.
避免数组本身是升序/降序造成面积求取失败，例如[2,4,6,8] [8,6,4,2].

时间复杂度为O(n)
空间复杂度为O(n)

代码如下

public static int largestRectangleArea(int[] heights) {
    if (heights == null)
        return 0;
    int maxArea = 0;// 最大矩形面积
    int[] heightsPro = new int[heights.length + 2];// 数组首尾添加数字0，兼容heights数组元素递增无法计算面积情况
    heightsPro[0] = 0;
    heightsPro[heightsPro.length - 1] = 0;
    for (int i = 1; i <= heights.length; i++)
        heightsPro[i] = heights[i - 1];

    Stack<Integer> stack = new Stack<>();// 单调栈
    stack.push(0);
    for (int i = 1; i < heightsPro.length; i++) {
        int top = stack.peek();

        if (heightsPro[i] < heightsPro[top]) {
            while (heightsPro[i] < heightsPro[top]) {
                int mid = stack.pop();// 栈顶元素

                if (stack.isEmpty())
                    break;

                top = stack.peek();// 栈顶的下一个元素
                int area = heightsPro[mid] * (i - top - 1);
                maxArea = Math.max(area, maxArea);
            }
        }

        stack.push(i);// 要入栈的元素

    }
    return maxArea;


}