接雨水——用dp或者双指针是最直观的解法
LeetCode 题解 | 42.接雨水
42.接雨水
接雨水 - 力扣(LeetCode)题目描述
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图,计算按此排列的柱子,下雨之后能接多少雨水。
![](https://pic3.zhimg.com/80/v2-405c9a2b30a357a962a4d6b21bd61682_720w.jpg)
上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图,在这种情况下,可以接 6 个单位的雨水(蓝色部分表示雨水)。感谢 Marcos 贡献此图。
示例:
输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6
解决方案
思路
黑色的看成墙,蓝色的看成水,宽度一样,给定一个数组,每个数代表从左到右墙的高度,求出能装多少单位的水。也就是图中蓝色正方形的个数。
解法一:按列求
求每一列的水,我们只需要关注当前列,以及左边最高的墙,右边最高的墙就够了。装水的多少,当然根据木桶效应,我们只需要看左边最高的墙和右边最高的墙中较矮的一个就够了。所以,根据较矮的那个墙和当前列的墙的高度可以分为三种情况。
- 较矮的墙的高度大于当前列的墙的高度
![](https://pic3.zhimg.com/80/v2-9068f12f4b59f6007b5c08e21f1bbd52_720w.jpg)
把正在求的列左边最高的墙和右边最高的墙确定后,然后为了方便理解,我们把无关的墙去掉。
![](https://pic4.zhimg.com/80/v2-b9e62bf137a0cc0e95f5410d5d53f5ab_720w.jpg)
这样就很清楚了,现在想象一下,往两边最高的墙之间注水。正在求的列会有多少水?很明显,较矮的一边,也就是左边的墙的高度,减去当前列的高度就可以了,也就是 2 - 1 = 1,可以存一个单位的水。
- 较矮的墙的高度小于当前列的墙的高度
![](https://pic4.zhimg.com/80/v2-807d3e01130854b151c476d22c052a2b_720w.jpg)
同样的,我们把其他无关的列去掉。
![](https://pic3.zhimg.com/80/v2-c3f0f5f7485ecf10f6590c1e33932176_720w.jpg)
想象下,往两边最高的墙之间注水。正在求的列会有多少水?
正在求的列不会有水,因为它大于了两边较矮的墙。
- 较矮的墙的高度等于当前列的墙的高度。
和上一种情况是一样的,不会有水。
![](https://pic1.zhimg.com/80/v2-9419d8245d02f92fb30e7736a11d993c_720w.jpg)
明白了这三种情况,程序就很好写了,遍历每一列,然后分别求出这一列两边最高的墙。找出较矮的一端,和当前列的高度比较,结果就是上边的三种情况。
Java 实现
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;
}
时间复杂度: ,遍历每一列需要
,找出左边最高和右边最高的墙加起来刚好又是一个
,所以是
。
空间复杂度:O(1)。
解法二: 动态规划
我们注意到,解法二中。对于每一列,我们求它左边最高的墙和右边最高的墙,都是重新遍历一遍所有高度,这里我们可以优化一下。
首先用两个数组,max_left [i]
代表第 i
列左边最高的墙的高度,max_right[i]
代表第 i
列右边最高的墙的高度。(一定要注意下,第 i 列左(右)边最高的墙,是不包括自身的,和力扣上边的讲的有些不同)
对于 max_left
我们其实可以这样求。
max_left [i] = Max(max_left [i-1]
,height[i-1])
。它前边的墙的左边的最高高度和它前边的墙的高度选一个较大的,就是当前列左边最高的墙了。对于 max_right我们可以这样求。max_right[i] = Max(max_right[i+1]
,height[i+1])
。它后边的墙的右边的最高高度和它后边的墙的高度选一个较大的,就是当前列右边最高的墙了。
这样,我们再利用解法二的算法,就不用在 for
循环里每次重新遍历一次求 max_left
和 max_right
了。
Java 实现
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 = 1; i < height.length - 1; i++) {
max_left[i] = Math.max(max_left[i - 1], height[i - 1]);
}
for (int i = height.length - 2; i >= 0; i--) {
max_right[i] = Math.max(max_right[i + 1], height[i + 1]);
}
for (int i = 1; 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),用来保存每一列左边最高的墙和右边最高的墙。
解法三:双指针
动态规划中,我们常常可以对空间复杂度进行进一步的优化。
例如这道题中,可以看到,max_left [ i ]
和 max_right [ i ]
数组中的元素我们其实只用一次,然后就再也不会用到了。所以我们可以不用数组,只用一个元素就行了。我们先改造下 max_left
。
public int trap(int[] height) {
int sum = 0;
int max_left = 0;
int[] max_right = new int[height.length];
for (int i = height.length - 2; i >= 0; i--) {
max_right[i] = Math.max(max_right[i + 1], height[i + 1]);
}
for (int i = 1; i < height.length - 1; i++) {
max_left = Math.max(max_left, height[i - 1]);
int min = Math.min(max_left, max_right[i]);
if (min > height[i]) {
sum = sum + (min - height[i]);
}
}
return sum;
}
我们成功将 max_left
数组去掉了。但是会发现我们不能同时把 max_right
的数组去掉,因为最后的 for
循环是从左到右遍历的,而 max_right
的更新是从右向左的。
所以这里要用到两个指针,left
和 right
,从两个方向去遍历。
那么什么时候从左到右,什么时候从右到左呢?根据下边的代码的更新规则,我们可以知道
max_left = Math.max(max_left, height[i - 1]);
height [ left - 1]
是可能成为 max_left
的变量,同理,height [ right + 1 ]
是可能成为 right_max
的变量。
只要保证 height [ left - 1 ] < height [ right + 1 ]
,那么 max_left
就一定小于 max_right
。
因为 max_left
是由 height [ left - 1]
更新过来的,而 height [ left - 1 ]
是小于 height [ right + 1]
的,而 height [ right + 1 ]
会更新max_right
,所以间接的得出 max_left
一定小于 max_right
。
反之,我们就从右到左更。
Java 实现
public int trap(int[] height) {
int sum = 0;
int max_left = 0;
int max_right = 0;
int left = 1;
int right = height.length - 2; // 加右指针进去
for (int i = 1; i < height.length - 1; i++) {
//从左到右更
if (height[left - 1] < height[right + 1]) {
max_left = Math.max(max_left, height[left - 1]);
int min = max_left;
if (min > height[left]) {
sum = sum + (min - height[left]);
}
left++;
//从右到左更
} else {
max_right = Math.max(max_right, height[right + 1]);
int min = max_right;
if (min > height[right]) {
sum = sum + (min - height[right]);
}
right--;
}
}
return sum;
}
时间复杂度: 。
空间复杂度: 。
解法四:栈
![](https://pic3.zhimg.com/80/v2-2ed49192931c03153cda0aa8c2466e52_720w.jpg)
说到栈,我们肯定会想到括号匹配了。我们仔细观察蓝色的部分,可以和括号匹配类比下。每次匹配出一对括号(找到对应的一堵墙),就计算这两堵墙中的水。
我们用栈保存每堵墙。
当遍历墙的高度的时候,如果当前高度小于栈顶的墙高度,说明这里会有积水,我们将墙的高度的下标入栈。
如果当前高度大于栈顶的墙的高度,说明之前的积水到这里停下,我们可以计算下有多少积水了。计算完,就把当前的墙继续入栈,作为新的积水的墙。
总体的原则就是,
- 当前高度小于等于栈顶高度,入栈,指针后移。
- 当前高度大于栈顶高度,出栈,计算出当前墙和栈顶的墙之间水的多少,然后计算当前的高度和新栈的高度的关系,重复第 2 步。直到当前墙的高度不大于栈顶高度或者栈空,然后把当前墙入栈,指针后移。
我们看具体的例子。
- 首先将
height [ 0 ]
入栈。然后current
指向的高度大于栈顶高度,所以把栈顶height [ 0 ]
出栈,然后栈空了,再把height [ 1 ]
入栈。current
后移。
![](https://pic3.zhimg.com/80/v2-f85ec4bebd014100511ccf2a1e9893d6_720w.jpg)
- 然后
current
指向的高度小于栈顶高度,height [ 2 ]
入栈,current
后移。
![](https://pic3.zhimg.com/80/v2-510ff77065f8c3995ff56f289824b732_720w.jpg)
- 然后
current
指向的高度大于栈顶高度,栈顶height [ 2 ]
出栈。计算height [ 3 ]
和新的栈顶之间的水。计算完之后继续判断current
和新的栈顶的关系。
![](https://pic2.zhimg.com/80/v2-d4a5d77a4bbb0dded184118b50c487ed_720w.jpg)
current
指向的高度大于栈顶高度,栈顶height [ 1 ]
出栈,栈空。所以把height [ 3 ]
入栈。currtent
后移。
![](https://pic2.zhimg.com/80/v2-23ce2f8e5c56a9a0356bfd45099a9a21_720w.jpg)
- 然后
current
指向的高度小于栈顶height [ 3 ]
的高度,height[ 4 ]
入栈。current
后移。
![](https://pic1.zhimg.com/80/v2-52488baa81ab05df49f99e1a0928c844_720w.jpg)
- 然后
current
指向的高度小于栈顶height [ 4 ]
的高度,height [ 5 ]
入栈。current
后移。
![](https://pic1.zhimg.com/80/v2-5b4ec04f344a399d7d2ed12a2d485238_720w.jpg)
- 然后
current
指向的高度大于栈顶height [ 5 ]
的高度,将栈顶height [ 5 ]
出栈,然后计算current
指向的墙和新栈顶height [ 4 ]
之间的水。计算完之后继续判断current
的指向和新栈顶的关系。此时height [ 6 ]
不大于栈顶height [ 4 ]
,所以将height [ 6 ]
入栈。current
后移。
![](https://pic1.zhimg.com/80/v2-e6902adf0283e4b7f59b2c6af0e1ab58_720w.jpg)
- 然后
current
指向的高度大于栈顶高度,将栈顶height [ 6 ]
出栈。计算和新的栈顶height [ 4 ]
组成两个边界中的水。然后判断current
和新的栈顶height [ 4 ]
的关系,依旧是大于,所以把height [ 4 ]
出栈。计算current
和 新的栈顶height [ 3 ]
之间的水。然后判断current
和新的栈顶height [ 3 ]
的关系,依旧是大于,所以把height [ 3 ]
出栈,栈空。将current
指向的height [ 7 ]
入栈。current
后移。
其实不停的出栈,可以看做是在找与 7 匹配的墙,也就是 3 。
![](https://pic4.zhimg.com/80/v2-c9ca3b6a004c6e739bff31603aec8a8b_720w.jpg)
而对于计算 current
指向墙和新的栈顶之间的水,根据图的关系,我们可以直接把这两个墙当做之前解法三的 max_left
和 max_right
,然后之前弹出的栈顶当做每次遍历的 height [ i ]
。水量就是 Min ( max _ left ,max _ right ) - height [ i ]
,只不过这里需要乘上两个墙之间的距离。可以看下代码继续理解下。
Java 实现
public int trap6(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;
}
int distance = current - stack.peek() - 1; //两堵墙之前的距离。
int min = Math.min(height[stack.peek()], height[current]);
sum = sum + distance * (min - h);
}
stack.push(current); //当前指向的墙入栈
current++; //指针后移
}
return sum;
}
时间复杂度:虽然 while
循环里套了一个 while
循环,但是考虑到每个元素最多访问两次,入栈一次和出栈一次,所以时间复杂度是 。
空间复杂度: 。栈的空间。
总结
解法一到解法二,利用动态规划,空间换时间,解法二到解法三,优化动态规划的空间,这一系列下来,让人心旷神怡。
本文作者:windliang