每日一练：接雨水

42. 接雨水 - 力扣（LeetCode）

一、题目要求

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

二、解法1-分层 O(N^2)

把柱子看成一层一层的，求每一层的雨水加起来即可，时间复杂度较高，会超时。

优化：每一层都排除无效柱子

class Solution {
public:
    int trap(vector<int>& height) {
        int ret = 0;
        int right = height.size() - 1;
        int left = 0;
        // 找到最长的柱子
        int maxlen = 0;
        for (auto& num : height) {
            if (num > maxlen)
                maxlen = num;
        }
        for (int i = 1; i <= maxlen; i++) {
            // 排除两端的无效柱子
            while (left < height.size() - 1 &&
                   height[left] <= height[left + 1] || height[left] < i) {
                left++;
            }
            while (right > 0 && height[right] <= height[right - 1] || height[right] < i) {
                right--;
            }
            if (left >= right)
                return ret;
            int first = left;
            while (first < right) {
                if (height[first] >= i) {
                    break;
                }
                first++;
            }
            int second = first + 1;
            while (second <= right) {
                if (height[first] >= i && height[second] >= i) {
                    ret += second - first - 1;
                    first = second;
                }
                second++;
            }
        }
        return ret;
    }
};

三、解法2-动态规划 O(N)

下标 i 位置可存储的水量等于：左右两边最长柱子中短柱子的长度 - i 位置柱子的长度，小于0就取0。

所以计算出每个位置左边的最长柱子的右边的最长柱子，取小值 - i 位置柱子的长度，然后累加起来即可。

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

        vector<int> rightMax(n);
        rightMax[n - 1] = height[n - 1];
        for (int i = n - 2; i >= 0; --i) {
            rightMax[i] = max(rightMax[i + 1], height[i]);
        }

        int ans = 0;
        for (int i = 0; i < n; ++i) {
            ans += min(leftMax[i], rightMax[i]) - height[i];
        }
        return ans;
    }
};

四、解法3-单调栈 O(N)

1. 单调递减栈：

   • 在栈中保持元素按递减顺序排列。
   • 当一个新元素比栈顶元素大或相等时，栈顶元素会被弹出，然后将新元素压入栈中。
   • 栈中的元素总是从栈底到栈顶单调递减的。

方法：

从左到右遍历数组，遍历到下标 i 时，如果栈内至少有两个元素，记栈顶元素为 top，top 的下面一个元素是 left，则一定有 height[left]≥height[top]。如果 height[i]>height[top]，则得到一个可以接雨水的区域，该区域的宽度是 i−left−1，高度是 min(height[left],height[i])−height[top]，根据宽度和高度即可计算得到该区域能接的雨水量。

为了得到 left，需要将 top 出栈。在对 top 计算能接的雨水量之后，left 变成新的 top，重复上述操作，直到栈变为空，或者栈顶下标对应的 height 中的元素大于或等于 height[i]。

在对下标 i 处计算能接的雨水量之后，将 i 入栈，继续遍历后面的下标，计算能接的雨水量。遍历结束之后即可得到能接的雨水总量。

作者：力扣官方题解
链接：https://leetcode.cn/problems/trapping-rain-water/solutions/692342/jie-yu-shui-by-leetcode-solution-tuvc/
来源：力扣（LeetCode）
 

class Solution {
public:
    int trap(vector<int>& height) {
        int ret = 0;
        stack<int> s;
        for (int i = 0; i < height.size(); i++) {
            while (!s.empty()&&height[s.top()] < height[i] ) {
                int v = s.top();
                s.pop();
                if(s.empty())
                    break;
                int left = s.top();
                int width = i-left-1;
                int heigh = min(height[left], height[i]) - height[v];
                ret += width*heigh;
            }
            s.push(i);
        }
        return ret;
    }
};

五、解法4-双指针 O(N)

维护两个指针 left 和 right，以及两个变量 leftMax 和 rightMax，初始时 left=0,right=n−1,leftMax=0,rightMax=0。指针 left 只会向右移动，指针 right 只会向左移动，在移动指针的过程中维护两个变量 leftMax 和 rightMax 的值。

当两个指针没有相遇时，进行如下操作：

使用 height[left] 和 height[right] 的值更新 leftMax 和 rightMax 的值；

如果 height[left]<height[right]，则必有 leftMax<rightMax，下标 left 处能接的雨水量等于 leftMax−height[left]，将下标 left 处能接的雨水量加到能接的雨水总量，然后将 left 加 1（即向右移动一位）；

如果 height[left]≥height[right]，则必有 leftMax≥rightMax，下标 right 处能接的雨水量等于 rightMax−height[right]，将下标 right 处能接的雨水量加到能接的雨水总量，然后将 right 减 1（即向左移动一位）。

为什么如果 height[left]<height[right]，则必有 leftMax<rightMax呢？

这是因为 left 和 right 都是小的才移动，大的不移动，值不变，leftMax的来源又是 left 曾经或者现在的值，移动后仍然符合 height[left]<height[right]，那么 leftMax 一定比 rightMax 小。

class Solution {
public:
    int trap(vector<int>& height) {
        int ret = 0;
        int left = 0,right = height.size()-1;
        int leftMax = 0,rightMax = 0;
        while(left < right)
        {
            leftMax = max(height[left],leftMax);
            rightMax = max(height[right],rightMax);
            if(height[left]<height[right])
            {
                ret+=leftMax-height[left];
                left++;
            }
            else
            {
                ret+=rightMax-height[right];
                right--;
            }
        }
        return ret;
    }
};