代码随想录算法训练营第五十五天 | 42. 接雨水、84.柱状图中最大的矩形、复习

42. 接雨水

题目链接：https://leetcode.cn/problems/trapping-rain-water/
文档讲解：https://programmercarl.com/0042.%E6%8E%A5%E9%9B%A8%E6%B0%B4.html
视频讲解：https://www.bilibili.com/video/BV1uD4y1u75P/

思路

双指针法

暴力解法是用一个for循环遍历数组，里面再用一个for循环找出当前柱子左右最高的柱子，然后当前柱子的储水量就是min(leftHight, rightHeight) - hight，时间复杂度为O(n²)。
使用双指针进行优化，用双指针对左右最高的柱子进行预处理，分别放入两个数组中。最后再用一个for循环来计算储水量。

单调栈法

用单调栈求右边比当前柱子高的柱子，找到之后，单调栈的下一个元素就是左边比当前柱子高的柱子（因为单调栈里单调递增）。单调栈里面存放的是下标。是横向求解，求解高h和宽w，储水量为h * w。

代码

双指针

class Solution {
    public int trap(int[] height) {
        int len = height.length, res = 0;
        int[] maxLeft = new int[len];
        int[] maxRight = new int[len];

        maxLeft[0] = height[0];
        for (int i = 1; i < len; i++) maxLeft[i] = Math.max(height[i], maxLeft[i - 1]);
        maxRight[len - 1] = height[len - 1];
        for(int i = len - 2; i >= 0; i--) maxRight[i] = Math.max(height[i], maxRight[i + 1]);

        for (int i = 0; i < len; i++) {
            int tmp = Math.min(maxLeft[i], maxRight[i]) - height[i];
            if (tmp > 0) res += tmp;
        }
        return res;
    }
}

单调栈

class Solution {
    public int trap(int[] height) {
        Deque<Integer> stack = new LinkedList<>();
        int res = 0;
        stack.push(0);
        for (int i = 1; i < height.length; i++) {
            while (!stack.isEmpty() && height[i] > height[stack.peek()]) {
                int midHeight = stack.pop();
                if (!stack.isEmpty()) res += (Math.min(height[i], height[stack.peek()]) - height[midHeight]) * (i - stack.peek() - 1);
            }
            stack.push(i);
        }
        return res;
    }
}

分析：时间复杂度：O(n)，空间复杂度：O(m)。

84.柱状图中最大的矩形

题目链接：https://leetcode.cn/problems/largest-rectangle-in-histogram/
文档讲解：https://programmercarl.com/0084.%E6%9F%B1%E7%8A%B6%E5%9B%BE%E4%B8%AD%E6%9C%80%E5%A4%A7…
视频讲解：https://www.bilibili.com/video/BV1Ns4y1o7uB/

思路

使用单调栈去找每个柱子左右比他矮的柱子，中间的距离就为宽w = right - left - 1，当前柱子的高度为h，则以当前柱子为基础能形成的最大面积为h * w，最后找出最大值。需要在数组首尾加上0，否则无法算出所有柱子的左右最小值。

代码

class Solution {
    public int largestRectangleArea(int[] heights) {
        Deque<Integer> st = new LinkedList<>();
        int[] newHieghts = new int[heights.length + 2];
        newHieghts[0] = 0;
        newHieghts[newHieghts.length - 1] = 0;
        for (int i = 1; i < newHieghts.length - 1; i++) newHieghts[i] = heights[i - 1];
        int max = 0;
        st.push(0);
        for (int i = 1; i < newHieghts.length; i++) {
            while (!st.isEmpty() && newHieghts[i] < newHieghts[st.peek()]) {
                int midHeight = st.pop();
                if (!st.isEmpty()) {
                    int s = newHieghts[midHeight] * (i - st.peek() - 1);
                    max = Math.max(max, s);
                }
            }
            st.push(i);
        }
        return max;
    }
}

分析：时间复杂度：O(n)，空间复杂度：O(n)。

复习栈与队列部分

232.用栈实现队列
225. 用队列实现栈
20. 有效的括号
1047. 删除字符串中的所有相邻重复项