Leetcode42. 接雨水

Every day a Leetcode

题目来源：42. 接雨水

解法1：前后缀分解

pre_max[i] 表示从 height[0] 到 height[i] 的最大值，suf_max[i] 表示从 height[i] 到 height[n-1] 的最大值。

将接雨水视为一个个底边长度为 1 的水桶，桶的高度是 min(pre_max[i], suf_max[i]) - height[i]，水桶的宽度为 1，接水量为两者的乘积。

代码：

/*
 * @lc app=leetcode.cn id=42 lang=cpp
 *
 * [42] 接雨水
 */

// @lc code=start

// 前后缀分解

class Solution
{
public:
    int trap(vector<int> &height)
    {
        int n = height.size();
        // pre_max[i] 表示从 height[0] 到 height[i] 的最大值
        vector<int> pre_max(n);
        pre_max[0] = height[0];
        for (int i = 1; i < n; i++)
            pre_max[i] = max(pre_max[i - 1], height[i]);
        // suf_max[i] 表示从 height[i] 到 height[n-1] 的最大值
        vector<int> suf_max(n);
        suf_max[n - 1] = height[n - 1];
        for (int i = n - 2; i >= 0; i--)
            suf_max[i] = max(suf_max[i + 1], height[i]);

        // 将接雨水视为一个个底边长度为 1 的水桶，
        // 水桶的高度是 min(pre_max[i], suf_max[i]) - height[i]
        // 水桶的宽度为 1，接水量为两者的乘积
        int sum = 0;
        for (int i = 0; i < n; i++)
            sum += min(pre_max[i], suf_max[i]) - height[i];
        return sum;
    }
};
// @lc code=end

结果：

复杂度分析：

时间复杂度：O(n)，其中 n 是数组 height 的元素个数。

空间复杂度：O(n)，其中 n 是数组 height 的元素个数。

解法2：相向双指针

本质上还是前后缀，但是不需要求出前后缀最大值数组，而是在双指针遍历过程中维护前缀最大值和后缀最大值，并计算当前水桶的接水量。

接水量的总和即为答案。

代码：

// 相向双指针

class Solution
{
public:
    int trap(vector<int> &height)
    {
        int n = height.size();
        int left = 0, right = n - 1;
        // pre_max 表示前缀最大值，suf_max 表示后缀最大值
        int pre_max = 0, suf_max = 0;
        int sum = 0;

        while (left < right)
        {
            // 更新前后缀最大值
            pre_max = max(pre_max, height[left]);
            suf_max = max(suf_max, height[right]);
            if (pre_max < suf_max)
            {
                sum += pre_max - height[left];
                left++;
            }
            else
            {
                sum += suf_max - height[right];
                right--;
            }
        }

        return sum;
    }
};

结果：

复杂度分析：

时间复杂度：O(n)，其中 n 是数组 height 的元素个数。

空间复杂度：O(1)。

解法3：单调栈

上面的方法相当于「竖着」计算面积，单调栈的做法相当于「横着」计算面积。

这个方法可以总结成 16 个字：找上一个更大元素，在找的过程中填坑。

注意 while 中加了等号，这可以让栈中没有重复元素，从而在有很多重复元素的情况下，使用更少的空间。

代码：

// 单调栈

class Solution
{
public:
    int trap(vector<int> &height)
    {
        int ans = 0;
        stack<int> st;
        for (int i = 0; i < height.size(); i++)
        {
            while (!st.empty() && height[i] >= height[st.top()])
            {
                int bottom_h = height[st.top()];
                st.pop();
                if (st.empty())
                    break;
                int left = st.top();
                // 面积的高和宽
                int dh = min(height[left], height[i]) - bottom_h;
                int dw = i - left - 1;
                ans += dh * dw;
            }
            st.push(i);
        }
        return ans;
    }
};

结果：

复杂度分析：

时间复杂度：O(n)，其中 n 是数组 height 的元素个数。

空间复杂度：O(min(n,U))，其中 U=max(height)−min(height)+1。注意栈中没有重复元素，在 height 值域很小的情况下，空间复杂度主要取决于 height 的值域范围。