LeetCode42. 接雨水

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

 

上面是由数组 [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

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

解析：

        该题目有多种解法，可以利用动态规划，两次遍历，计算每个点左右两侧的最大值，即可得出当前点的盛水量。

代码：

class Solution {
public:
    int trap(vector<int>& height) {
        int size=height.size();
        if(size==0)
            return 0;
        int res=0;
        vector<int> dp(size,0);
        int mx=0;
        for(int i=0;i<size;i++)//计算i的左侧最大值
        {
            dp[i]=mx;
            mx=max(mx,height[i]);
        }
        mx=0;
        for(int i=size-1;i>=0;i--)//计算右侧最大值，去左右两侧最大值中较小的值，计算盛水量
        {
            dp[i]=min(dp[i],mx);
            mx=max(height[i],mx);
            if(dp[i]>height[i])res+=dp[i]-height[i];
        }
        return res;
    }
};

2、利用双指针，分别指向首尾元素，取两个数较小的一侧。如果左侧较小，则左指针移动，如果右侧较小，则右指针移动。由于总能知道左右侧最大值中较小的值，则可以判断每个点的盛水量。

代码：

class Solution {
public:
    int trap(vector<int>& height) {
        int size=height.size();
        if(size==0)
            return 0;
        int res=0;
        int l=0,r=size-1;
        while(l<r)
        {
            int mn=min(height[l],height[r]);//求较小值
            if(mn==height[l])
            {
                l++;
                while(l<r&&height[l]<mn)//左侧右移
                {
                    res+=mn-height[l];
                    l++;
                }
            }
            else
            {
                r--;
                while(l<r&&height[r]<mn)//右侧左移
                {
                    res+=mn-height[r];
                    r--;
                }
            }
        }
        return res;
    }
};

3、利用单调栈，单调递减的存储高度，当遇到大于栈顶元素高度值时，将栈顶元素弹出并记录大小，根据现在栈顶元素和当前高度值的大小，得出弹出元素左右最大值中的最小值，容易得出弹出元素位置可以存储的水量。

代码：

class Solution {
public:
    int trap(vector<int>& height) {
        int size=height.size();
        if(size==0)
            return 0;
        int res=0;
        stack<int>s;
        int i=0;
        while(i<size)
        {
            if(s.empty()||height[s.top()]>height[i])//单调递减栈
                s.push(i++);
            else
            {
                int top=s.top();
                s.pop();
                if(s.empty())//如果左侧没有值，则构不成坑
                    continue;
                int m=min(height[s.top()],height[i]);
                res+=(m-height[top])*(i-s.top()-1);//高度差*距离
            }
        }
        return res;
    }
};

参考：https://www.cnblogs.com/grandyang/p/4402392.html