算法---LeetCode 42. 接雨水

1. 题目

原题链接

给定 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
0 <= n <= 3 * 104
0 <= height[i] <= 105

Related Topics 栈 数组 双指针 动态规划
👍 2195 👎 0

2. 题解

2.1 解法1: 按列求解

1. 遍历每列
2. 每次找到左边与右边的最高值
3. 取两者小值与 当前列高比较, 只有两边都高于当前列时, 才能装水

    class Solution {
        public int trap(int[] height) {
            int ans = 0;
            for (int i = 1; i < height.length - 1; i++) {
                int leftMax = 0, rightMax = 0;
                // 从左开始, 寻找左边最高
                for (int j = i - 1; j >= 0; j--) {
                    leftMax = Math.max(leftMax, height[j]);
                }
                // 找右边最高
                for (int j = i + 1; j < height.length; j++) {
                    rightMax = Math.max(rightMax, height[j]);
                }
                // 找到两端最小的值
                int min = Math.min(leftMax, rightMax);
                // 只有两边都高于当前列时, 才能装水
                if (min > height[i]) {
                    ans += (min - height[i]);
                }

            }
            return ans;
        }
    }

参考: 详细通俗的思路分析，多解法

2.2 解法2: 基于题解1的动态规划

1. 使用两个数组 来保存, 左侧和右侧的最大高度,
   通过递推方式计算, 如 leftMax[i]=Math.max(leftMax[i-1],height[i-1])
2. 然后 遍历高度数组, 计算体积结果

    class Solution {
        public int trap(int[] height) {
            int[] leftMax = new int[height.length];
            int[] rightMax = new int[height.length];
            int ans = 0;
            for (int i = 1; i < height.length; i++) {
                leftMax[i] = Math.max(leftMax[i - 1], height[i - 1]);
            }
            for (int i = height.length - 2; i >= 0; i--) {
                rightMax[i] = Math.max(rightMax[i + 1], height[i + 1]);
            }
            for (int i = 1; i < height.length - 1; i++) {
                int min = Math.min(leftMax[i], rightMax[i]);
                if (min > height[i]) {
                    ans += (min - height[i]);
                }
            }
            return ans;
        }
    }

参考: 详细通俗的思路分析，多解法

2.3 解法3: 双指针

• 定义
  left_max：左边的最大值(不包含left下标)，它是从左往右遍历找到的
  right_max：右边的最大值(不包含right下标)，它是从右往左遍历找到的
  left：从左往右处理的当前下标
  right：从右往左处理的当前下标

1. 相当于每次计算 下标为 left或right列的雨水量
2. 当我们从左往右处理到left下标时，左边的最大值left_max对它而言是可信的，但right_max对它而言是不可信的。
   反之, 当我们从右往左处理到right下标时，右边的最大值right_max对它而言是可信的，但left_max对它而言是不可信的。
3. 对于位置left而言，它左边最大值一定是left_max，右边最大值“大于等于”right_max，这时候，如果left_max<right_max成立，
   那么它就知道自己能存多少水了

    class Solution {
        public int trap(int[] height) {
            int ans = 0;
            int leftMax = 0;
            int rightMax = 0;
            int left = 0;
            int right = height.length - 1;
            while (left <= right) {
                if (leftMax < rightMax) { // 这时可确定 leftMax 最小, 移动左指针
                    ans += Math.max(0, leftMax - height[left]);
                    // 保存新值, 移动指针
                    leftMax = Math.max(leftMax, height[left]);
                    left++;
                } else { // 这时可确定 rightMax 最小, 移动右指针
                    ans += Math.max(0, rightMax - height[right]);
                    // 保存新值, 移动指针
                    rightMax = Math.max(rightMax, height[right]);
                    right--;
                }
            }

            return ans;
        }
    }

参考: 官方题解评论

2.4 解法4: 单调栈

维护一个单调递减栈，单调栈存储的是下标，满足从栈底到栈顶的下标对应的数组 height 中的元素递减。

如果当前高度小于栈顶的墙高度，说明这里会有积水，我们将墙的高度的下标入栈。
如果当前高度大于栈顶的墙的高度，说明之前的积水到这里停下，我们可以计算下有多少积水了。计算完，就把当前的墙继续入栈，作为新的积水的墙。

    class Solution {
        public int trap(int[] height) {
            LinkedList<Integer> stack = new LinkedList<>();
            int ans = 0;
            for (int i = 0; i < height.length; i++) {
                // 当栈不为空且非单调时, 出栈计算雨量, 关键 while
                while (!stack.isEmpty() && height[i] > height[stack.peek()]) {
                    int top = stack.pop();
                    if (stack.isEmpty()) {
                        break;
                    }
                    int left = stack.peek();
                    int currWidth = i - left - 1;
                    int currHeight = Math.min(height[left], height[i]) - height[top];
                    ans += currHeight * currWidth;
                }
                stack.push(i);
            }
            return ans;
        }
    }

参考: 官方题解