Leetcode | 42.接雨水 Trapping Rain Water
文章目录
- [Leetcode | 42.接雨水 Trapping Rain Water](#Leetcode | 42.接雨水 Trapping Rain Water)
题目
给定 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.length1 <= n <= 2 * 1040 <= height[i] <= 105
Solution 1:动态规划
接雨水的情况，就是左边和右边都要有边，中间低洼才能接雨水。
因此只要找到左右边界即可。
遍历2遍，分别提前存储每个位置上，所有左边柱子高度的最大值和右边柱子高度的最大值
然后将左右柱子最大值，重叠在一起看，其重叠区域除去柱子高度，就是能够接到雨水的量
只有当前高度值比左右柱子最大高度小，才能接到雨水，如果当前柱子高度与左右最大高度柱子其中之一一样高，则跳过，说明当前柱子是后面低洼处的一个边界。
cpp
class Solution {
public:
int trap(vector<int>& height) {
int num = height.size();
if(num == 0 || num < 3) {
return 0;
}
int arr_max_left[num];
int arr_max_right[num];
// 获取左边最大高度柱子
int max = height[0];
for(int i = 0; i < num; ++i) {
auto &cur_num = height[i];
if(cur_num > max) {
max = cur_num;
}
arr_max_left[i] = max;
}
// 获取右边最大高度柱子
max = height[num - 1];
for(int i = num - 1; i >= 0; --i) {
auto &cur_num = height[i];
if(cur_num > max) {
max = cur_num;
}
arr_max_right[i] = max;
}
// 左右边界一起和当前柱子进行比较
int result = 0;
for(int i = 0; i < num ; ++i) {
auto &cur_num = height[i];
int min_num = std::min(arr_max_left[i], arr_max_right[i]);
if(cur_num < min_num) {
result += min_num - cur_num;
}
}
return result;
}
};
Solution 2: 单调栈
积水只能在低洼处形成，当后面柱子比前面柱子低时，是无法接雨水的。
使用单调栈存储可能储水的柱子，当找到1个比前面柱子高的柱子时，就能够计算储水量。
也就是， 柱子高度上升时，可以计算积水；当柱子高度下降时，表示到达了积水的右边界。
积水高度为当前元素与栈顶元素的高度的较小值 与 当前栈top元素的高度差
也就是从栈顶取出的元素为低洼处的柱子序号，取出之后，栈顶top元素为积水的左边界。
边界条件：存入栈时，只要当前柱子比栈顶柱子低，或栈为空，就将当前柱子序号存入栈；当前柱子高度比栈顶元素高时，即可以计算积水。
cpp
class Solution {
public:
int trap(vector<int>& height) {
int num = height.size();
if(num == 0 || num < 3) {
return 0;
}
int result = 0;
std::stack<int> stk;
for(int i = 0; i < num; ++i) {
while(!stk.empty() && height[i] > height[stk.top()]) {
int low = stk.top();
stk.pop();
if(stk.empty()) {
break;
}
int dis = i - stk.top() - 1;
int h = std::min(height[i], height[stk.top()]) - height[low];
result += dis * h;
}
stk.push(i);
}
return result;
}
};
一开始我想着一次性计算两个柱子之间的积水量，发现边界非常不好确定。这种方法是，只要柱子比前面高，就能计算一波，后面柱子更高时，再在此基础上继续计算积水量，这样边界就非常明显了。
Solution 3 : 双指针
从动态规划方法可以注意到，其实只要 $ arr_max_left[i] > arr_max_right[i]$ ，积水高度就由较低的右边界决定。
同理，如果 $ arr_max_left[i] < arr_max_right[i]$ ，积水高度就由较低的左边界决定。
所以当遍历的时候，只要左右有最大高度的柱子，就可以积水。可以通过记录左右柱子高度的最大值，计算当前柱子上方的储水量。
还是注意一点，如果当前柱子高度同最大高度柱子高度一样，则不进行计算，或增加量为0。
cpp
class Solution {
public:
int trap(vector<int>& height) {
int num = height.size();
if(num == 0 || num < 3) {
return 0;
}
int left = 0, right = num - 1;
int max_left = 0, max_right = 0, result = 0;
while(left < right) {
if(height[left] < height[right]) {
if(height[left] > max_left) {
max_left = height[left];
} else {
result += max_left - height[left];
}
++left;
} else {
if(height[right] > max_right) {
max_right = height[right];
} else {
result += max_right - height[right];
}
--right;
}
}
return result;
}
};
最快的方法代码
简洁优雅
cpp
class Solution {
public:
int trap(vector<int>& height) {
int sz = height.size(), l = 0, r = sz-1;
int ans = 0, maxl = 0, maxr = 0;
while (l<r)
{
maxl = max(maxl, height[l]);
maxr = max(maxr, height[r]);
if (maxl < maxr)
{
ans += max(0, maxl - height[l]);
++l;
}
else
{
ans += max(0, maxr - height[r]);
--r;
}
}
return ans;
}
};其精髓在于，不管左边高右边高，只要当前柱子比最大的柱子低，我就计算增量maxl - height[l]或maxr - height[r]；
如果当前柱子和最大高度一样高，则增量为0 ：max(0, maxl - height[l])或max(0, maxr - height[r])，这么写，天下就大一统了，妙哉。
ans += max(0, maxl - height[l]);
ans += max(0, maxr - height[r]);
My Solution
将所有的柱子，划分为2维空间里面，蓝色的为柱子，其他彩色为积水量
每次计算时，从低到高，从左到右，依次遍历这个2维数组
只要2个蓝色的小方块中间有空白，就表示此处可以积水，积水量 +1，每一行计算完后，行数 + 1，继续遍历。
cpp
class Solution {
public:
int trap(vector<int>& height) {
int num = height.size();
if(num == 0 || num == 1) {
return 0;
}
int max = height[0];
for(int i =1; i < num; ++i) {
int &cur_num = height[i];
if(cur_num > max) {
max=cur_num;
}
}
int result = 0;
for(int i = 0; i < max; ++i) {
bool begin = false;
bool last_empty = true;
int temp = 0;
for(int j =0; j < num; ++j) {
int &cur_num = height[j];
if(cur_num > i) {
if(!begin) {
begin = true;
} else if(temp > 0) {
// begin = false;
result += temp;
temp = 0;
}
continue;
} else {
if(!begin) {
continue;
} else {
++temp;
}
}
}
}
return result;
}
};这种方法无形中增加了遍历的量，原本1维遍历能够搞定的事情，现在要2维遍历
对于下面的例子，就会超时
bash
[100000,0,99999,0,99998,0,99997,0,99996,0,99995,0,
99994,0,99993,0,99992,0,99991,0,99990,0,99989,0,
99988,0,99987,0,99986,0,99985,0,99984,0,99983,0,
99982,0,99981,0,99980,0,99979,0,99978,0,99977,0,
99976,0,99975,0,99974,0,99973,0,99972,0,99971,0,
99970,0,99969,0,99968,0,99967,0,99966,0,99965,0,
99964,0,99963,0,99962,0,99961,0,99960,0,99959,0,
99958,0,99957,0,99956,0,99955,0,99954,0,99953,0,
>>>>> 中间省略N行 <<<<<
99718,0,99717,0,99716,0,99715,0,99714,0,99713,0,
99712,0,99711,0,99710,0,99709,0,99708,0,99707,0,
99706,0,99705,0,99704,0,99703,0,99702,0,99701,0,
99700,0,99699,0,99698,0,99697,0,99696,0,99695,0,
99694,0,99693,0,99692,0,99691,0,99690,0,99689,0,
99688,0,99687,0,99686,0,99685,0,99684,0,99683,0,
99682,0,99681,0,99680,0,99679,0,99678,0,99677,0]所以搞清楚边界条件很重要，不要增加遍历维度。