【LeetCode刷题（困难程度）】42. 接雨水

给定 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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/trapping-rain-water
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

暴力法：（超时）
对于除第一个节点和最后一个节点以外的每个节点，我们都找到该节点左边和右边的最大墙高max_left和max_right，然后取其中最小者，其实观察可以发现，对于当前节点来说，其能存储的水的体积就是min(max_left,max_right) - height[i]，例如就以图中的例子为例：在i=4时即其位置对应的那滴水的体积就是min(2,3) - 1 = 1，当遍历完这个高度数组时,ans也就求和完了。

class Solution {
public:
    int trap(vector<int>& height) {
        int ans = 0;
        int size = height.size();
        for(int i = 1;i < size - 1;++i)
        {
            int max_left = 0;
            int max_right = 0;
            for(int j = i;j >= 0;--j)//从当前位置往左找
            {
                max_left = max(max_left,height[j]);
            }
            for(int j = i;j < size;++j)//从当前位置往右找
            {
                max_right = max(max_right,height[j]);
            }
            ans += min(max_left,max_right) - height[i];
        }
        return ans;
    }
};

动态规划法：
根据暴力法改进，我们可以利用两个数组分别求出当前位置左边的对应的左最大值，和当前位置右边对应的右最大值，然后再来计算即可。

class Solution {
public:
    int trap(vector<int>& height) {
        int ans = 0;
        int size = height.size();
        if(size == 0)
            return 0;
        
        vector<int> max_left(size,0);
        vector<int> max_right(size,0);
        max_left[0] = height[0];
        max_right[size - 1] = height[size -1];
        for(int i = 1;i < size;++i)
        {
            max_left[i] = max(height[i],max_left[i - 1]);
        }
        for(int i = size -2;i >= 0;--i)
        {
            max_right[i] = max(height[i],max_right[i + 1]);
        }
        for(int i = 1;i < size - 1;++i)
        {
            ans += min(max_left[i],max_right[i]) - height[i];
        }
        return ans;
    }
};

双指针法：
我们可以从两边向中间进行遍历，需要知道的是，对于当前节点来说，如果是从左往右方向，那么只有左边的最大值是可信的；如果是从右往左，那么只有右边最大值是可信的。

class Solution {
public:
    int trap(vector<int>& height) {
        int ans = 0;
        int left = 0;
        int right = height.size()-1;

        int left_max = 0;
        int right_max = 0;
        while(left < right)
        {
            left_max = max(left_max,height[left]);
            right_max = max(right_max,height[right]);

            //从左往右方向
            if(left_max <= right_max)//左边最大值对于当前节点来说可信
            {
                ans += left_max - height[left];
                ++left;
            }
            //从右往左方向
            else//右边最大值对于当前节点来说可信
            {
                ans += right_max - height[right];
                --right;
            }
        }
        return ans;
    }
};

单调栈版本：

class Solution {
public:
    int trap(vector<int>& height) {
        int ret = 0;
        stack<int>s;
        int temp = 0;
        //维护的是一个单调递减栈
        for(int i = 0;i < height.size();++i)
        {
            while(!s.empty() && height[i] > height[s.top()])
            {
                int cur = height[s.top()];//这里是凹槽的高度
                s.pop();
                int l = s.empty() ? -1:s.top();

                if(l == -1)
                    continue;
                else//height是右边的高度 当前栈顶是左边的高度
                    ret += (min(height[s.top()]-cur,height[i] - cur))*(i - l - 1);
            }
            s.push(i);//push的时候height肯定不大于 栈顶元素
        }
        return ret;
    }
};