华为笔试——一个仓库摆放了一排连续整齐的长宽不等的矩形箱子...海报可用的最大矩形面积

1 题目描述

一个仓库的一排连续整齐的摆放了长宽不等的$n$个箱子$(n=[1,100])$，现在要这些高低不等的箱子组成的柱形图中，找出一块最大的完整矩形面积来贴一张海报。
输入输出描述
输入：依次给出$n$个矩形箱子的宽度$[1,100]$和高度$[1,100]$。为简化起见，最多20个箱子。
输出：海报可用的最大矩形面积。

输入输出示例：
输入
[1,1,1,1,2,1,1],[5,2,5,4,5,1,6]
输出
16

2 直观思路

我们需要在柱状图中找出最大的矩形，因此我们可以考虑枚举矩形的宽和高，其中宽表示矩形贴着柱状图底边的宽度，高表示矩形在柱状图上的高度。

2.1 直接遍历——暴力法

方法一：枚举宽

如果我们枚举宽，我们可以使用两重循环枚举矩形的左右边界以固定宽度 $w$，此时矩形的高度 $h$，就是所有包含在内的柱子的最小高度，对应的面积为 $w\ast h$。

    public int largestRectangleArea(int[] widths, int[] heights) {
        int n = heights.length;
        int ans = 0;
        // 枚举左边界
        for (int left = 0; left < n; ++left) {
            int minHeight = Integer.MAX_VALUE;
            // 枚举右边界
            for (int right = left; right < n; ++right) {
                // 确定高度
                minHeight = Math.min(minHeight, heights[right]);
                // 确定宽度
                int widthSum = 0;
                for (int i = left; i <= right; i++) {
                    widthSum += widths[i];
                }
                // 计算面积
                ans = Math.max(ans, widthSum * minHeight);
            }
        }
        return ans;
    }

方法二：枚举高

如果我们枚举高，我们可以使用一重循环枚举某一根柱子，将其固定为矩形的高度 $h$。随后我们从这跟柱子开始向两侧延伸，直到遇到高度小于 $h$ 的柱子，就确定了矩形的左右边界。如果左右边界之间的宽度为 $w$，那么对应的面积为 $w\ast h$。

    int largestRectangleArea2(int[] widths, int[] heights) {
        int n = heights.length;
        int ans = 0;
        for (int mid = 0; mid < n; ++mid) {
            // 枚举高
            int height = heights[mid];
            int left = mid, right = mid;
            // 确定左右边界
            while (left - 1 >= 0 && heights[left - 1] >= height) {
                --left;
            }
            while (right + 1 < n && heights[right + 1] >= height) {
                ++right;
            }
            // 确定宽度
            int widthSum = 0;
            for (int i = left; i <= right; i++) {
                widthSum += widths[i];
            }
            // 计算面积
            ans = Math.max(ans, widthSum * height);
        }
        return ans;
    }

直接遍历复杂度分析

时间复杂度：$O(n^2)$。确定左右边界供需循环$n^2$次。
空间复杂度：$O(1)$。使用常数空间。

3 单调栈——优化时间复杂度

    public int largestRectangleArea3(int[] widths, int[] heights) {
        int n = heights.length;
        int[] left = new int[n];
        int[] right = new int[n];

        Stack<Integer> mono_stack = new Stack<>();
        for (int i = 0; i < n; ++i) {
            while (!mono_stack.isEmpty() && heights[mono_stack.peek()] >= heights[i]) {
                mono_stack.pop();
            }
            left[i] = (mono_stack.isEmpty() ? -1 : mono_stack.peek()) + widths[i] -1;
            mono_stack.push(i);
        }

        mono_stack.clear();
        for (int i = n - 1; i >= 0; --i) {
            while (!mono_stack.isEmpty() && heights[mono_stack.peek()] >= heights[i]) {
                mono_stack.pop();
            }
            right[i] = (mono_stack.isEmpty() ? n : mono_stack.peek()) + widths[1] -1;
            mono_stack.push(i);
        }

        int ans = 0;
        for (int i = 0; i < n; ++i) {
            ans = Math.max(ans, (right[i] - left[i]) * heights[i]);
        }
        return ans;
    }

    public int maxArea(int[] width, int[] height) {
        int heightLength = height.length;
        int maxArea = 0;
        for (int j = 0; j < heightLength; j++) {
            int currentHeight = height[j];
            int currentArea = 0;
            if (j == 0 || j == heightLength -1) {
                currentArea = height[j] * width[j];
            }
            else if (currentHeight > height[j + 1]) { // 下一个高度小于当前值
                continue;
            }
            else { // 下一个高度大于等于当前值，向左向右寻找，直到小于当前值，停止，计算当前面积
                currentArea = searchMaxHeight(width, height, j) + height[j] * width[j];
            }
            maxArea = Math.max(maxArea, currentArea);
        }
        return maxArea;
    }