【实战】双指针经典问题：接雨水问题

题意&示例

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

上面是由数组 [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

思路&代码

方法一：暴力破解

直观想法

直接按问题描述进行。对于数组中的每个元素，我们找出下雨后水能达到的最高位置，等于两边最大高度的较小值减去当前高度的值。

算法

• 初始化 ans = 0
• 从左向右扫描数组：
  • 初始化 max_left = 0 和 max_right = 0
  • 从当前元素向左扫描并更新：
    • max_left = max(max_left, height[j])
  • 从当前元素向右扫描并更新：
    • max_right = max(max_right, height[j])
  • 将 min(max_left, max_right) - height[i] 累加到 ans

// 暴力解法
public int trap(int[] height) {
    int ans = 0;

    int size = height.length;
    for (int i = 1; i < size - 1; i++) {
        int max_left = 0, max_right = 0;
        for (int j = i; j >= 0; j--) {
            //Search the left part for max bar size
            max_left = Math.max(max_left, height[j]);
        }
        for (int j = i; j < size; j++) {
            //Search the right part for max bar size
            max_right = Math.max(max_right, height[j]);
        }
        ans += Math.min(max_left, max_right) - height[i];
    }

    return ans;
}

复杂度分析

• 时间复杂度：O(n^2)，数组中的每个元素都需要向左向右扫描；
• 空间复杂度：O(1)的额外空间。

方法二：动态编程

直观想法

在暴力方法中，我们仅仅为了找到最大值每次都要向左和向右扫描一次。但是我们可以提前存储这个值。因此，可以通过动态编程解决。

这个概念可以见下图解释：

算法

• 找到数组中从下标 i 到最左端最高的条形块高度 left_max。
• 找到数组中从下标 i 到最右端最高的条形块高度right_max。
• 扫描数组 height 并更新答案：
  • 累加 min(max_left[i], max_right[i]) - height[i] 到 ans 上

public int trap(int[] height) {
    //特值判断
    if (height == null || height.length == 0) {
            return 0;
    }

    int ans = 0;
    int size = height.length;
    int[] left_max = new int[size];
    int[] right_max = new int[size];

    left_max[0] = height[0];
    for(int i = 1; i < size; i++) {
        left_max[i] = Math.max(height[i], left_max[i - 1]);
    }

    right_max[size - 1] = height[size - 1];
    for (int i = size - 2; i >= 0; i--) {
        right_max[i] = Math.max(height[i], right_max[i + 1]);
    }
    for (int i = 1; i < size - 1; i++) {
        ans += Math.min(left_max[i], right_max[i]) - height[i];
    }

    return ans;
}

复杂度分析

• 时间复杂度：O(n)。
  • 存储最大高度数组，需要两次遍历，每次O(n)；
  • 最终使用存储的数据更新 ans，O(n)。
• 空间复杂度：O(n) 额外空间。
  • 和方法 1 相比使用了额外的 O(n) 空间来放置 left_max 和 right_max 数组。

方法三：栈的应用

直观想法

我们可以不用像方法二那样存储最大高度，而是用”栈“来跟踪可能储水的最长的条形块。使用栈就可以在一次遍历内完成计算。

// TODO

方法四：使用双指针

直观想法

和方法二相比，我们不从左和右分开计算，我们想办法一次完成遍历。

从动态编程方法的示意图中我们注意到，只要 right_max[i] > left_max[i]（元素 0 到元素6），积水高度将有 left_max 决定，类似地 left_max[i] > right_max[i]（元素 8 到元素 11）。

所以我们可以认为如果一端有更高的条形块（例如右端），积水的高度依赖于当前方向的高度（从左到右）。当我们发现另一侧（右侧）的条形块高度不是最高的，我们则开始从相反的方向遍历（从右到左）。

我们必须在遍历时维护 left_max 和 right_max，但是我们现在可以使用两个指针交替进行，实现 1 次遍历即可完成。

算法

• 初始化 left 指针为 0 并且 right 指针为 size - 1；
• while (left < right), do:
  • if (height[left] < height[right])
    • if (height[left] >= left_max)，更新 left_max
    • else 累加 left_max - height[left] 到 ans
    • left = left + 1
  • else
    • if (height[right] >= right_max)，更新 right_max
    • else 累加 right_max - height[right] 到 ans
    • right = right - 1

代码

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

    while (left < right) {
        if (height[left] < height[right]) {
            if (height[left] >= leftMax) {
                leftMax = height[left];
            } else {
                ans += (leftMax - height[left]);
            }
            left++;
        } else {
            if (height[right] >= rightMax) {
                rightMax = height[right];
            } else {
                ans += (rightMax - height[right]);
            }
            right--;
        }
    }

    return ans;
}