LeetCode042之接雨水(相关话题：动态规划，单调栈)

数据与后端架构提升之路

已于 2023-12-30 23:04:46 修改

阅读量369

点赞数

分类专栏： # 算法文章标签：动态规划 leetcode 数据结构

于 2023-01-30 00:40:18 首次发布

本文链接：https://blog.csdn.net/lzhcoder/article/details/128795091

版权

算法专栏收录该内容

125 篇文章 3 订阅

订阅专栏

题目描述

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

示例 2：

输入：height = [4,2,0,3,2,5]
输出：9

提示：

n == height.length
1 <= n <= 2 * 104
0 <= height[i] <= 105

解法一:以列为中心左右拓展求单位积水

求每一列的水，我们只需要关注当前列，以及左边最高的墙，右边最高的墙就够了。

装水的多少，当然根据木桶效应，我们只需要看左边最高的墙和右边最高的墙中较矮的一个就够了。

所以，根据较矮的那个墙和当前列的墙的高度可以分为三种情况。

较矮的墙的高度大于当前列的墙的高度

把正在求的列左边最高的墙和右边最高的墙确定后，然后为了方便理解，我们把无关的墙去掉。

这样就很清楚了，现在想象一下，往两边最高的墙之间注水。正在求的列会有多少水？

很明显，较矮的一边，也就是左边的墙的高度，减去当前列的高度就可以了，也就是 2 - 1 = 1(红色处)，可以存一个单位的水。

较矮的墙的高度小于或等于当前列的墙的高度

public int trap(int[] height) {
    int sum = 0;
    //最两端的列不用考虑，因为一定不会有水。所以下标从 1 到 length - 2
    for (int i = 1; i < height.length - 1; i++) {
        int max_left = 0;
        //找出左边最高
        for (int j = i - 1; j >= 0; j--) {
            if (height[j] > max_left) {
                max_left = height[j];
            }
        }
        int max_right = 0;
        //找出右边最高
        for (int j = i + 1; j < height.length; j++) {
            if (height[j] > max_right) {
                max_right = height[j];
            }
        }
        //找出两端较小的
        int min = Math.min(max_left, max_right);
        //只有较小的一段大于当前列的高度才会有水，其他情况不会有水
        if (min > height[i]) {
            sum = sum + (min - height[i]);
        }
    }
    return sum;
}

解法二: 动态规划

我们注意到，上述解法一中。对于每一列，我们求它左边最高的墙和右边最高的墙，都是重新遍历一遍所有高度，这里我们可以优化一下。

首先用两个数组，max_left [i] 代表第 i 列左边最高的墙的高度，max_right[i] 代表第 i 列右边最高的墙的高度。

对于 max_left我们其实可以这样求。

max_left [i+1] = Max(max_left [i],height[i])。它前边的墙的左边的最高高度和它前边的墙的高度选一个较大的，就是当前列左边最高的墙了。

对于 max_right我们可以这样求。

max_right[i-1] = Max(max_right[i],height[i]) 。它后边的墙的右边的最高高度和它后边的墙的高度选一个较大的，就是当前列右边最高的墙了。

这样，我们再利用解法一的算法，就不用在 for 循环里每次重新遍历一次求 max_left 和 max_right 了。

public int trap(int[] height) {
    int sum = 0;
    int[] max_left = new int[height.length];
    int[] max_right = new int[height.length];
    
    for (int i = 0; i < height.length - 1; i++) {
        max_left[i+1] = Math.max(max_left[i], height[i]);
    }
    for (int i = height.length - 1; i > 0; i--) {
        max_right[i-1] = Math.max(max_right[i], height[i]);
    }
    for (int i = 0; i < height.length - 1; i++) {
        int min = Math.min(max_left[i], max_right[i]);
        if (min > height[i]) {
            sum = sum + (min - height[i]);
        }
    }
    return sum;
}

解法三: 单调栈

解法一和解法二虽然直观可是时间复杂度太高，下面是如何用单调栈思解决这个问题的思路

为什么单调栈方法也是正确的

单调栈方法之所以正确，是因为它考虑了局部最高点来计算积水量。虽然这个局部最高点可能不是整个区间的最高点，但它确保了在当前的左右边界内，积水量的计算是准确无误的。当遍历整个数组时，所有的局部积水量加起来就等于总的积水量。

具体的算法步骤

初始化一个空栈，然后遍历每根柱子。

对于每根柱子，如果栈为空，或当前柱子的高度小于栈顶柱子的高度，那么我们将当前柱子的索引压入栈中。这是因为我们可能在后面找到一个更高的柱子，使得当前柱子和栈顶柱子之间的空间可以接雨水。

如果当前柱子的高度大于栈顶柱子的高度，那么就存在一个凹槽可以接雨水。我们可以计算凹槽的面积，并累加到结果中。计算面积的方法是：取栈顶柱子和当前柱子的较小高度，减去凹槽底部的高度（即栈顶柱子的下一根柱子的高度），然后乘以凹槽的宽度（即栈顶柱子和当前柱子的距离减一）。然后将栈顶柱子出栈。

重复上述步骤，直到遍历完所有柱子。

最后返回接到的雨水的总量。

这个解法的时间复杂度是O(n)，空间复杂度也是O(n)，其中n是柱子的数量。

而对于计算 current 指向墙和新的栈顶之间的水，根据图的关系，我们可以直接把这两个墙当做之前解法二的 max_left 和 max_right，然后之前弹出的栈顶当做每次遍历的 height [ i ]。水量就是 Min ( max _ left ，max _ right ) - height [ i ]，只不过这里需要乘上两个墙之间的距离。可以看下代码继续理解下。

public int trap(int[] height) {
    int sum = 0;
    Stack<Integer> stack = new Stack<>();
    int current = 0;
    while (current < height.length) {
        //如果栈不空并且当前指向的高度大于栈顶高度就一直循环
        while (!stack.empty() && height[current] > height[stack.peek()]) {
            int h = height[stack.peek()]; //取出要出栈的元素
            stack.pop(); //出栈
            if (stack.empty()) { // 栈空就出去
                break; 
            }
            //当前墙(i) , 栈顶墙(j), j出栈后的栈顶墙(k)
            //计算i和k之间的距离
            int distance = current - stack.peek() - 1; 
            //计算i和k对应墙的最小高度
            int min = Math.min(height[stack.peek()], height[current]);
            //单调栈需要乘以距离，这是和解法一解法二计算法方法的一个比较大的差异点
            sum = sum + distance * (min - h);
        }
        stack.push(current); //当前指向的墙入栈
        current++; //指针后移
    }
    return sum;
}