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.length
• 1 <= n <= 2 * 104
• 0 <= height[i] <= 105

Solution 1:动态规划

接雨水的情况，就是左边和右边都要有边，中间低洼才能接雨水。

因此只要找到左右边界即可。

遍历2遍，分别提前存储每个位置上，所有左边柱子高度的最大值和右边柱子高度的最大值

然后将左右柱子最大值，重叠在一起看，其重叠区域除去柱子高度，就是能够接到雨水的量

只有当前高度值比左右柱子最大高度小，才能接到雨水，如果当前柱子高度与左右最大高度柱子其中之一一样高，则跳过，说明当前柱子是后面低洼处的一个边界。

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元素为积水的左边界。

边界条件：存入栈时，只要当前柱子比栈顶柱子低，或栈为空，就将当前柱子序号存入栈；当前柱子高度比栈顶元素高时，即可以计算积水。

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。

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;
    }
};

最快的方法代码

简洁优雅

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，继续遍历。

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维遍历

对于下面的例子，就会超时

[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]

所以搞清楚边界条件很重要，不要增加遍历维度。

Reference

• 官方题解：接雨水

---

>>>>> 欢迎关注公众号【三戒纪元】 <<<<<