42. Trapping Rain Water 及类似题目 407. Trapping Rain Water II 11. Container With Most Water

42. Trapping Rain Water

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

For example, 
Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.

The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcosfor contributing this image!

思路1：对每个台阶都寻找左右最大的围墙

对于每一个台阶，都向左和向右寻找最高的那个墙壁，那么最终这个台阶的需水量等于min(maxRight,maxLeft)-height[i]代码如下：

时间复杂度是O(n2)

int trap(vector<int>& height){    int ans = 0;    int size = height.size();    for (int i = 1; i < size - 1; i++) {        int max_left = 0, max_right = 0;        for (int j = i; j >= 0; j--) { //Search the left part for max bar size            max_left = max(max_left, height[j]);        }        for (int j = i; j < size; j++) { //Search the right part for max bar size            max_right = max(max_right, height[j]);        }        ans += min(max_left, max_right) - height[i];    }    return ans;}

思路2：动态规划方法，建立左右墙壁两个数组

上图的意思是：

分两步考虑，对于一个台阶，只看他左边的最高墙壁，认为右边墙壁和左边墙壁相等，这样每个台阶的储水量都可以求得。而且，左边最高墙壁可以在一次遍历过程中不断更新（只有当前墙壁高于之前的最高墙壁才会更新）；

同样的道理，可以得到只考虑右边墙壁时得到的各台阶的需水量。

一个台阶的实际需水量等于上面两个数组相应位置的最小值。

实际左右分开遍历矩阵时，只需要保存最高墙壁。最后一次遍历时再求需水量

int trap(vector<int>& height){    if(height == null)        return 0;    int ans = 0;    int size = height.size();    vector<int> left_max(size), right_max(size);    left_max[0] = height[0];    for (int i = 1; i < size; i++) {//从左至右遍历，保存当前台阶的左边最大墙壁        left_max[i] = max(height[i], left_max[i - 1]);    }    right_max[size - 1] = height[size - 1];    for (int i = size - 2; i >= 0; i--) {//从右至左遍历，保存当前台阶的左边最大墙壁 right_max[i] = max(height[i], right_max[i + 1]); } for (int i = 1; i < size - 1; i++) {//左右墙壁的最小值-当前台阶的高度是当前台阶的需水量        ans += min(left_max[i], right_max[i]) - height[i];    }    return ans;}

思路3：使用栈 时间复杂度O(n)，空间复杂度O(n)
可以在一次遍历求得最大需水量
栈为空时，先进栈。
栈不为空时：如果栈顶元素高度大于等于当前高度current，进栈；如果栈顶元素小于当前高度，出栈，计算出栈的元素的蓄水量，找到现在的栈顶和current的最小高度，乘以两个墙壁的距离得到蓄水量，这个蓄水量是栈顶元素做墙的蓄水量。然后继续比较current和栈顶，如果还是满足current>栈顶，继续重复上述操作。这种蓄水方式实际上是一层一层的注水。（这个可以实现的原因是，栈顶的下面的高度一定大于等于上面的值）
当前蓄水完成之后（这些节点的蓄水量一定是全部加完的），再将current进栈，重复外层循环。

int trap(vector<int>& height){    int ans = 0, current = 0;    stack<int> st;    while (current < height.size()) {        while (!st.empty() && height[current] > height[st.top()]) {            int top = st.top();            st.pop();            if (st.empty())                break;            int distance = current - st.top() - 1;            int bounded_height = min(height[current], height[st.top()]) - height[top];            ans += distance * bounded_height;        }        st.push(current++);    }    return ans;}

思路4：使用双指针
这个方法较难想到：
left。right分别在两端，分别保存左右最大值，如果左墙壁最大值小于右墙壁最大值，那么左指针当前台阶的蓄水量由左墙壁决定，这个时候更新左墙壁（因为下一个左墙壁可能还小与右墙壁）。
相反，如果左墙壁最大值大于等于右墙壁最大值，那么右指针当前台阶的蓄水量由右墙壁决定，这个时候更新右墙壁（因为下一个右墙壁可能还小与左墙壁）。
Time complexity: O(n)O(n). Single iteration of O(n)O(n).
Space complexity: O(1)O(1) extra space. Only constant space required for \text{left}left, \text{right}right, left_maxleft_max and right_maxright_max.

int trap(vector<int>& height){    int left = 0, right = height.size() - 1;    int ans = 0;    int left_max = 0, right_max = 0;    while (left < right) {        if (height[left] < height[right]) {            height[left] >= left_max ? (left_max = height[left]) : ans += (left_max - height[left]);            ++left;        }        else {            height[right] >= right_max ? (right_max = height[right]) : ans += (right_max - height[right]);            --right;        }    }    return ans;}

11. Container With Most Water


Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.


Note: You may not slant the container and n is at least 2.


寻找两条线，他们围成得水池蓄水最多


两个指针分别从左和右向中间逼近。每次计算水池大小（与全局变量比较）。向中间逼近时，只有遇到更高得柱子，才考虑更新水池大小。

class Solution {public:    int maxArea(vector<int>& height) {        int n=height.size();        int areamax=0;        int i=0,j=n-1;        while(i<j)        {            int hmin=min(height[i],height[j]);            areamax=max(areamax,(j-i)*hmin);        while(height[i]<=hmin&&i<j) {                ++i;            }            while(height[j]<=hmin&&i<j) {                j--;            }        }        return areamax;    }};

Leetcode 407. Trapping Rain Water II 收集雨水2 解题报告 使用优先级队列，用pair<int,int> 将矩阵坐标转换成一维值

class Solution {public:    int trapRainWater(vector<vector<int>>& heightMap) {        typedef pair<int,int> cell;        priority_queue<cell, vector<cell>, greater<cell>> q;        int m = heightMap.size();        if (m == 0) return 0;        int n = heightMap[0].size();        vector<int> visited(m*n, false);                for (int i = 0; i < m; ++i)        for (int j = 0; j < n; ++j) {            if (i == 0 || i == m-1 || j == 0  || j == n-1) {                if (!visited[i*n+j])                    q.push(cell(heightMap[i][j], i*n+j));                visited[i*n+j] = true;            }        }                int dir[4][2] = {{0,1}, {0, -1}, {1, 0}, {-1, 0}};        int ans = 0;        while(!q.empty()) {            cell c = q.top();            q.pop();            int i = c.second/n, j = c.second%n;                        for (int r = 0; r < 4; ++r) {                int ii = i+dir[r][0], jj = j+dir[r][1];                if (ii < 0 || ii >= m || jj < 0 || jj >= n || visited[ii*n+jj])                    continue;                ans += max(0, c.first - heightMap[ii][jj]);                q.push(cell(max(c.first, heightMap[ii][jj]), ii*n+jj));                visited[ii*n+jj] = true;            }        }        return ans;    }};