【双指针】42. 接雨水【困难】

接雨水

• 给定 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 个单位的雨水（蓝色部分表示雨水）。

实现1容易理解，实现2稍微绕了一点点

解题思路1

• 1、首先，我们需要找到每个柱子能够容纳的雨水量，即当前柱子上方的最大高度减去当前柱子的高度。
• 2、对于每个柱子，我们需要找到它左边和右边的最大高度，然后取两者中较小的值为上方的最大高度，减去当前柱子的高度，即为当前柱子能容纳的雨水量。
• 3、将所有柱子的容纳雨水量相加即可得到总的雨水量。

具体步骤1

• 1、使用两个数组 leftMax 和 rightMax 分别记录每个柱子左边和右边的最大高度。
• 2、分别从左往右和从右往左遍历数组，更新 leftMax 和 rightMax。
• 3、遍历数组，计算每个柱子能容纳的雨水量，累加得到总的雨水量。

java实现1

public class TrappingRainWater {
    public int trap(int[] height) {
        if (height == null || height.length == 0) return 0;

        int n = height.length;
        int[] leftMax = new int[n];
        int[] rightMax = new int[n];
        
        // 计算每个柱子左边的最大高度
        leftMax[0] = height[0];
        for (int i = 1; i < n; i++) {
            leftMax[i] = Math.max(leftMax[i - 1], height[i]);
        }
        
        // 计算每个柱子右边的最大高度
        rightMax[n - 1] = height[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            rightMax[i] = Math.max(rightMax[i + 1], height[i]);
        }
        
        int totalWater = 0;
        // 计算每个柱子能容纳的雨水量
        for (int i = 0; i < n; i++) {
            totalWater += Math.min(leftMax[i], rightMax[i]) - height[i];
        }
        
        return totalWater;
    }

    public static void main(String[] args) {
        TrappingRainWater solution = new TrappingRainWater();
        int[] height = {0,1,0,2,1,0,1,3,2,1,2,1};
        System.out.println(solution.trap(height)); // 输出：6
    }
}

时间空间复杂度1

时间复杂度：O(n)，其中 n 是数组 height 的长度。

空间复杂度：O(n)，用来存储左右两边的最大高度。

解题思路2

• 1、首先，我们需要找到每个柱子能够容纳的雨水量，即当前柱子上方的最大高度减去当前柱子的高度。
• 2、对于左边的柱子，我们需要找到它左边当前的最大高度为其上方的最大高度，减去当前柱子的高度，即为当前柱子能容纳的雨水量。右边同理。
• 3、将所有柱子的容纳雨水量相加即可得到总的雨水量。

具体步骤2

• 1、使用两个指针 left 和 right 分别指向数组的起始和结束位置。
• 2、使用两个变量 leftMax 和 rightMax 分别记录左右两侧的最大高度，初始值设为 0。
• 3、在 while 循环中，动态更新 leftMax 和 rightMax。
• 4、当左侧的高度小于右侧时，计算左侧当前位置能存储的雨水量，并将 left 指针向右移动；
  反之，计算右侧当前位置能存储的雨水量，并将 right 指针向左移动。
• 5、直到 left 和 right 指针相遇，结束循环，返回结果。

Java代码2

public class TrappingRainWater {

    public int trap(int[] height) {
        int left = 0;
        int right = height.length - 1;
        int leftMax = 0;
        int rightMax = 0;
        int result = 0;

        while (left < right) {
            // 更新左侧最大值和右侧最大值
            leftMax = Math.max(leftMax, height[left]);
            rightMax = Math.max(rightMax, height[right]);
            //每次移动柱子较低的一侧，一直到最高柱子
            //if (height[left] < height[right]) {
            if(maxLeft < maxRight){
                // 左侧较低，计算当前位置能存储的雨水
                result += leftMax - height[left];
                left++;
            } else {
                // 右侧较低，计算当前位置能存储的雨水
                result += rightMax - height[right];
                right--;
            }
        }

        return result;
    }

    public static void main(String[] args) {
        TrappingRainWater solution = new TrappingRainWater();

        int[] height1 = {0,1,0,2,1,0,1,3,2,1,2,1};
        System.out.println(solution.trap(height1)); // 输出：6

        int[] height2 = {4,2,0,3,2,5};
        System.out.println(solution.trap(height2)); // 输出：9
    }
}

时间空间复杂度2

时间复杂度：O(n)，其中 n 是数组 height 的长度。

空间复杂度：O(1)。