LeetCode #41 接雨水

LeetCode #41 接雨水

题目描述

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

方法一：暴力法（超出时间限制）

对于每一个元素下雨后水等达到的最高位置，等于两边的最大高度减去当前位置的值，每个元素都向左向右遍历算出最大高度

class Solution:
    def trap(self, height: List[int]) -> int:
        ans = 0
        for i in range(len(height)):
            max_left, max_right = 0, 0
            # 比较时要包括自己，防止自己是最高点相减出现负数
            for j in range(i + 1):
                max_left = max(height[j], max_left)
            for j in range(i, len(height)):
                max_right = max(height[j], max_right)
            ans += min(max_left, max_right) - height[i]
        return ans

• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(1)$

方法二：动态编程

跟方法一思路差不多，对于每一个元素，找到左边最大高度和右边最大高度，提前存储，用空间换时间

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;
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/trapping-rain-water/solution/jie-yu-shui-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

• 时间复杂度：$O(n)$：存储最大高度数组需要两次 $O(n)$，更新ans需要一次 $O(n)$
• 空间复杂度：$O(n)$：使用了额外 $O(n)$ 的空间来放置 (left_max, right_max) 数组

方法三：双指针

1. 找出最高点
2. 分别从两边往最高点遍历：如果下一个数比当前数小，说明可以接到水
3. 不需要担心可能出现一遍高一边低导致算多了的情况，因为这个高是当前区间内相对的高，在和最高点对比时它就变成两边最高位置的最小值了

class Solution:
    def trap(self, height: List[int]) -> int:
        if len(height) <= 1:
            return 0
        
        max_height = 0
        max_height_index = 0

        # 找到最高点
        for i in range(len(height)):
            if height[i] > max_height:
                max_height = height[i]
                max_height_index = i
        
        ans = 0

        # 从左往最高点遍历
        tmp = height[0]
        for i in range(max_height_index):
            if height[i] > tmp:
                tmp = height[i]
            else:
                ans += tmp - height[i]

        # 从右往最高点遍历
        tmp = height[-1]
        for i in range(len(height) - 1, max_height_index, -1):
            if height[i] > tmp:
                tmp = height[i]
            else:
                ans += tmp - height[i]
        
        return ans

• 时间复杂度：$O(n)$：三次遍历，每次 $O(n)$
• 空间复杂度：$O(1)$：只需要常数个变量记录

方法四：面积法

评论区 @狂奔的蜗牛，超级巧妙！

• h1 从左边遍历到右边，最高点左边的面积为水+柱子；最高点右边用最高的柱子填满
• h2 从右边遍历到左边，最高点右边的面积为水+柱子；最高点左边用最高的柱子填满
• 这样相加后的总面积 = (左边的水+柱子) + (右边的水+柱子) + 以最高点为高的矩形面积，所以只要减去柱子的面积和矩形的面积就能得到水的面积

class Solution:
    def trap(self, height: List[int]) -> int:
        ans = 0
        h1 = 0
        h2 = 0
        # 超级巧妙的一次循环完成了从左往右和从右往左的遍历！
        for i in range(len(height)):
            h1 = max(h1,height[i])
            h2 = max(h2,height[-i-1])
            # 减去柱子的面积
            ans = ans + h1 + h2 -height[i]
       	# 最后要减去矩形的面积
        return  ans - len(height)*h1

时间复杂度：$O(n)$：需要从左往右和从右往左两次遍历 $O(n)$
空间复杂度：$O(1)$：只需要记录最高点的高度