单调栈题目：接雨水

题目

标题和出处

标题：接雨水

出处：42. 接雨水

难度

6 级

题目描述

要求

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

示例

示例 1：

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

示例 2：

输入：$\text{height = [4,2,0,3,2,5]}$
输出：$\text{9}$

数据范围

• $\text{n}=\text{height.length}$
• $\text{1}\le \text{n}\le \text{2}\times {\text{10}}^{\text{4}}$
• $\text{0}\le \text{height[i]}\le {\text{10}}^{\text{5}}$

解法一

思路和算法

下标 $i$ 处的雨水能达到的高度等于其两边的最大高度的最小值，下标 $i$ 处的雨水能达到的高度与 $\text{height}[i]$ 之差即为下标 $i$ 处的雨水量。只要得到每个下标处的两边最大高度，即可得到能接的雨水总量。

朴素的解法是对于每个下标分别向两边遍历找到最大高度，对于长度为 $n$ 的数组 $\text{height}$，每个下标需要 $O(n)$ 的时间找到两边的最大高度，总时间复杂度是 $O(n^2)$。如果可以预计算每个下标两边的最大高度，则可以将总时间复杂度降到 $O(n)$。

创建两个长度为 $n$ 的数组 $\text{leftHeight}$ 和 $\text{rightHeight}$，对于 $0\le i<n$，$\text{leftHeight}[i]$ 表示 $\text{height}$ 在下标范围 $[0,i]$ 内的最大元素，$\text{rightHeight}[i]$ 表示 $\text{height}$ 在下标范围 $[i,n-1]$ 内的最大元素。

数组 $\text{leftHeight}$ 和 $\text{rightHeight}$ 的计算方法如下：

• 对于 $\text{leftHeight}$，$\text{leftHeight}[0]=\text{height}[0]$，当 $1\le i<n$ 时 $\text{leftHeight}[i]=\max (\text{leftHeight}[i-1],\text{height}[i])$，从左到右依次计算 $\text{leftHeight}$ 的值；

• 对于 $\text{rightHeight}$，$\text{rightHeight}[n-1]=\text{height}[n-1]$，当 $0\le i<n-1$ 时 $\text{rightHeight}[i]=\max (\text{rightHeight}[i+1],\text{height}[i])$，从右到左依次计算 $\text{rightHeight}$ 的值。

得到数组 $\text{leftHeight}$ 和 $\text{rightHeight}$ 之后，即可计算每个下标处的雨水量。下标 $i$ 处的雨水能到达的高度是 $\min (\text{leftHeight}[i],\text{rightHeight}[i])$，因此下标 $i$ 处的雨水量是 $\min (\text{leftHeight}[i],\text{rightHeight}[i])-\text{height}[i]$。遍历全部下标，计算每个下标处的雨水量，即可得到能接的雨水总量。

下图是示例 1 使用该解法的体现。红色和黄色分别表示 $\text{leftHeight}$ 和 $\text{rightHeight}$ 的值，橙色表示能接的雨水。

代码

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        int[] leftHeight = new int[n];
        leftHeight[0] = height[0];
        for (int i = 1; i < n; i++) {
            leftHeight[i] = Math.max(leftHeight[i - 1], height[i]);
        }
        int[] rightHeight = new int[n];
        rightHeight[n - 1] = height[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            rightHeight[i] = Math.max(rightHeight[i + 1], height[i]);
        }
        int amount = 0;
        for (int i = 0; i < n; i++) {
            amount += Math.min(leftHeight[i], rightHeight[i]) - height[i];
        }
        return amount;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{height}$ 的长度。需要遍历数组 $\text{height}$ 两次分别计算数组 $\text{leftHeight}$ 和 $\text{rightHeight}$，以及遍历数组 $\text{height}$ 一次计算能接的雨水总量。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{height}$ 的长度。需要创建两个长度为 $n$ 的数组 $\text{leftHeight}$ 和 $\text{rightHeight}$。

解法二

思路和算法

对于下标 $i$，如果存在下标 $\text{prev}$ 和 $\text{curr}$，满足 $\text{prev}<\text{curr}<i$ 且 $\text{height}[\text{prev}]$ 和 $\text{height}[i]$ 都大于 $\text{height}[\text{curr}]$，则存在一个能接雨水的区域。

由此可以使用单调栈计算能接的雨水总量。单调栈存储数组 $\text{height}$ 的下标，满足从栈底到栈顶的下标对应的元素单调递减。

从左到右遍历数组 $\text{height}$，当遍历到下标 $i$ 时，如果栈内至少有两个下标且栈顶下标对应的高度小于或等于当前高度（即 $\text{height}[i]$），记栈顶下标为 $\text{curr}$，$\text{curr}$ 的下面一个下标是 $\text{prev}$，其中 $\text{prev}<\text{curr}<i$，则得到一个能接雨水的区域，该区域的横向下标范围是 $[\text{prev}+1,i-1]$，竖向高度范围是 $[\text{height}[\text{curr}],\min (\text{height}[\text{prev}],\text{height}[i])]$，因此该区域能接的雨水量是 $(i-\text{prev}-1)\times (\min (\text{height}[\text{prev}],\text{height}[i])-\text{height}[\text{curr}])$。

由于栈顶下标为 $\text{curr}$，其下面一个下标是 $\text{prev}$，因此将 $\text{curr}$ 出栈之后的新栈顶下标为 $\text{prev}$。根据 $\text{prev}$、$\text{curr}$ 和 $i$ 计算能接的雨水量之后，$\text{prev}$ 变成新的 $\text{curr}$，重复上述操作，直到栈为空或者栈顶下标对应的高度大于当前高度。然后将 $i$ 入栈，继续遍历后面的下标并计算能接的雨水量，遍历结束时即可得到能接的雨水总量。

下面是示例 1 使用单调栈计算能接的雨水总量的过程。

1. 下标 $0$ 处的元素是 $0$，将 $0$ 入栈，$\text{stack}=[0:0]$，其中左边为栈底，右边为栈顶，栈内存储下标，为了方便阅读加上了下标对应的元素值。

2. 下标 $1$ 处的元素是 $1$，由于 $0<1$（根据上述逻辑，此处应该是 $0\le 1$，由于不相等因此写成小于号，下同），因此将 $0$ 出栈，由于栈为空因此不计算能接的雨水量，将 $1$ 入栈，$\text{stack}=[1:1]$。

3. 下标 $2$ 处的元素是 $0$，将 $2$ 入栈，$\text{stack}=[1:1,2:0]$。

4. 下标 $3$ 处的元素是 $2$，计算能接的雨水量。

   1. 由于 $0<2$，因此将 $2$ 出栈，$\text{curr}=2$，$\text{prev}=1$，$i=3$，能接雨水的区域是图中的 $\text{A}$ 区域，能接的雨水量是 $(3-2-1)\times (1-0)=1$，$\text{amount}$ 更新为 $1$。

   2. 由于 $1<2$，因此将 $1$ 出栈，由于栈为空因此不计算能接的雨水量，将 $3$ 入栈，$\text{stack}=[3:2]$。

5. 下标 $4$ 处的元素是 $1$，将 $4$ 入栈，$\text{stack}=[3:2,4:1]$。

6. 下标 $5$ 处的元素是 $0$，将 $5$ 入栈，$\text{stack}=[3:2,4:1,5:0]$。

7. 下标 $6$ 处的元素是 $1$，计算能接的雨水量。

   1. 由于 $0<1$，因此将 $5$ 出栈，$\text{curr}=5$，$\text{prev}=4$，$i=6$，能接雨水的区域是图中的 $\text{B}$ 区域，能接的雨水量是 $(6-4-1)\times (1-0)=1$，$\text{amount}$ 更新为 $2$。

   2. 由于 $1=1$（根据上述逻辑，此处应该是 $1\le 1$，由于相等因此写成等号，下同），因此将 $4$ 出栈，$\text{curr}=4$，$\text{prev}=3$，$i=6$，能接的雨水量是 $(6-3-1)\times (1-1)=0$，$\text{amount}$ 更新为 $2$。

   3. 将 $6$ 入栈，$\text{stack}=[3:2,6:1]$。

8. 下标 $7$ 处的元素是 $3$，计算能接的雨水量。

   1. 由于 $1<3$，因此将 $6$ 出栈，$\text{curr}=6$，$\text{prev}=3$，$i=7$，能接雨水的区域是图中的 $\text{C}$ 区域，能接的雨水量是 $(7-3-1)\times (2-1)=3$，$\text{amount}$ 更新为 $5$。

   2. 由于 $2<3$，因此将 $3$ 出栈，由于栈为空因此不计算能接的雨水量，将 $7$ 入栈，$\text{stack}=[7:3]$。

9. 下标 $8$ 处的元素是 $2$，将 $8$ 入栈，$\text{stack}=[7:3,8:2]$。

10. 下标 $9$ 处的元素是 $1$，将 $9$ 入栈，$\text{stack}=[7:3,8:2,9:1]$。

11. 下标 $10$ 处的元素是 $2$，计算能接的雨水量。

    1. 由于 $1<2$，因此将 $9$ 出栈，$\text{curr}=9$，$\text{prev}=8$，$i=10$，能接雨水的区域是图中的 $\text{D}$ 区域，能接的雨水量是 $(10-8-1)\times (2-1)=1$，$\text{amount}$ 更新为 $6$。

    2. 由于 $2=2$，因此将 $8$ 出栈，$\text{curr}=8$，$\text{prev}=7$，$i=10$，能接的雨水量是 $(10-7-1)\times (1-1)=0$，$\text{amount}$ 更新为 $6$。

    3. 将 $10$ 入栈，$\text{stack}=[7:3,10:2]$。

12. 下标 $11$ 处的元素是 $1$，将 $11$ 入栈，$\text{stack}=[7:3,10:2,11:1]$。

能接的雨水总量 $\text{amount}=6$。

代码

class Solution {
    public int trap(int[] height) {
        int amount = 0;
        Deque<Integer> stack = new ArrayDeque<Integer>();
        int n = height.length;
        for (int i = 0; i < n; i++) {
            while (!stack.isEmpty() && height[stack.peek()] <= height[i]) {
                int curr = stack.pop();
                if (stack.isEmpty()) {
                    break;
                }
                int prev = stack.peek();
                int currWidth = i - prev - 1;
                int currHeight = Math.min(height[prev], height[i]) - height[curr];
                amount += currWidth * currHeight;
            }
            stack.push(i);
        }
        return amount;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{height}$ 的长度。需要遍历数组 $\text{height}$ 一次，每个下标最多入栈和出栈各一次。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{height}$ 的长度。空间复杂度主要取决于栈空间，栈内元素个数不会超过 $n$。

解法三

思路和算法

解法一使用两个数组 $\text{leftHeight}$ 和 $\text{rightHeight}$ 存储每个下标左边和右边的最大高度，空间复杂度是 $O(n)$。可以使用双指针和两个变量代替两个数组，将空间复杂度降到 $O(1)$。

创建两个变量 $\text{left}$ 和 $\text{right}$ 表示左右指针，以及两个变量 $\text{leftHeight}$ 和 $\text{rightHeight}$ 分别表示左指针和右指针遍历到的最大高度，初始时 $\text{left}=0$，$\text{right}=n-1$，$\text{leftHeight}=0$，$\text{rightHeight}=0$。

计算能接的雨水总量的做法如下：

1. 使用 $\text{height}[\text{left}]$ 和 $\text{height}[\text{right}]$ 分别更新 $\text{leftHeight}$ 和 $\text{rightHeight}$；

2. 比较 $\text{leftHeight}$ 和 $\text{rightHeight}$ 的大小并更新能接的雨水总量：

   • 如果 $\text{leftHeight}<\text{rightHeight}$，则下标 $\text{left}$ 处的雨水量是 $\text{leftHeight}-\text{height}[\text{left}]$，将下标 $\text{left}$ 处的雨水量加到能接的雨水总量，然后将 $\text{left}$ 加 $1$；

   • 如果 $\text{leftHeight}\ge \text{rightHeight}$，则下标 $\text{right}$ 处的雨水量是 $\text{rightHeight}-\text{height}[\text{right}]$，将下标 $\text{right}$ 处的雨水量加到能接的雨水总量，然后将 $\text{right}$ 减 $1$；

3. 重复第 1 步和第 2 步，直到 $\text{left}=\text{right}$，即两个指针相遇，此时结束计算，得到能接的雨水总量。

代码

class Solution {
    public int trap(int[] height) {
        int amount = 0;
        int left = 0, right = height.length - 1;
        int leftHeight = 0, rightHeight = 0;
        while (left < right) {
            leftHeight = Math.max(leftHeight, height[left]);
            rightHeight = Math.max(rightHeight, height[right]);
            if (leftHeight < rightHeight) {
                amount += leftHeight - height[left];
                left++;
            } else {
                amount += rightHeight - height[right];
                right--;
            }
        }
        return amount;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{height}$ 的长度。两个指针的移动次数之和不超过 $n$。

• 空间复杂度：$O(1)$。