Leetcode 42 接雨水

Leetcode 42 接雨水

困难题，有多种解法，比如：单调栈，动态规划，双指针

题目

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

解法

单调栈

单调栈顾名思义，栈中的元素都是单调递增或者单调递减；

• 计算方式：储水区域需要左墙+右墙+深度，如果出现不规则形状的储水池按照从下向上计算(横向考虑)
• 具体方法
  • 这里可以维护一个单调递减栈，存储的是递减元素的下标；
  • 如果出现了新元素 right 比栈顶元素更大，意味着，栈顶元素处可以储水，新元素也就是右墙；
  • 弹出栈顶元素 cur（该元素是此元素储水的底部高度的下标）；
  • 新栈顶元素 left 就是左墙；
  • 对于cur元素的左墙和右墙及深度，此储水面积为$(right-left-1)\ast (min(height[right],height[left])-height[cur])$，也就是宽度✖深度;

class Solution:
    def trap(self, height: List[int]) -> int:
        stack, result = [], 0 #单调递减栈
        for i in range(len(height)):
            x = height[i]
            while stack and height[stack[-1]]<x:  #如果该元素比栈顶还要大，说明找到了储水的右墙，开始寻找左墙
                low = height[stack.pop()]
                if not stack: break  #如果没有左墙直接退出计算面积
                left = stack[-1]
                result += (i-left-1)*(min(x,height[left])-low)  #可能depth为0 说明还未找到真正的左墙
            stack.append(i)  #如果栈为空或者元素满足单调递减
        return result

• 时间复杂度 O(n)
• 空间复杂度 O(n)

动态规划

对于下标 i 的元素，下雨后能够接到雨水的最大高度是该元素所在水池的左墙和右墙高度决定的，常规的做法是对该元素分别向左，向右遍历，找到左墙和右墙[左边最大元素，右边最大元素]，就可以计算该区域可以储水的面积（纵向考虑），找寻左右墙需要O(n), 这种方式的需要$O(n^2)$。

class Solution:
    def trap(self, height: List[int]) -> int:
        result = 0
        for i in range(len(height)):
            left = right = height[i]
            l = r = i
            for l in range(i,-1,-1):
                if height[l]>left: left=height[l]
            for r in range(i,len(height)):
                if height[r]>right: right=height[r]
            result += min(right,left) - height[i] 
        return result

这种方式会超时；
上述做法时间复杂度较高的原因是对每个位置都需要左右两边遍历，如果已经存储每个位置两边最大的高度就可以在O(n)的时间内得到雨水总量，如何存储两边最大的高度呢，可以使用两个数组leftmax，rightmax记录每个元素的左侧最大值，右侧最大值；

如下代码使用动态规划得到leftmax，rightmax，再得到每个位置的储水量。

class Solution:
    def trap(self, height: List[int]) -> int:
        result = 0
        leftmax, rightmax = height.copy(), height.copy()
        for i in range(1,len(height)): leftmax[i] = max(leftmax[i], leftmax[i-1])
        for i in range(len(height)-2,-1,-1): rightmax[i] = max(rightmax[i], rightmax[i+1])
        for i in range(len(height)): result += min(leftmax[i],rightmax[i])-height[i]
        return result

• 时间复杂度：O(n)
• 空间复杂度：O(n)

双指针

动态规划是使用两个数组来维护每个位置的左右墙大小，空间复杂度为O(n)，注意到leftmax是从左到右遍历，rightmax是从右向左遍历；如果使用两个遍历来存储左右最大值，用双指针来遍历就可以将复杂度降低到O(1)；
用 leftmax 和 rightmax 存储左右最大值，用left，right作为双指针遍历【遍历途中维护两个最大值】；如果在双指针遍历过程中:

• 左墙小于等于右墙高度，意味着left指针是可以存储水的，储水量为leftmax-height[left]（也有可能为0）
• 左墙小于等于右墙高度，意味这right指针可以存储水的，储水量为rightmax-height[right]（也有可能为0）
• 如果left>right则停止遍历

class Solution:
    def trap(self, height: List[int]) -> int:
        result, leftmax, rightmax = 0, 0, 0
        left, right = 0, len(height)-1
        while left<=right:
            leftmax = max(height[left],leftmax)
            rightmax = max(height[right],rightmax)
            if leftmax<=rightmax:
                result += leftmax - height[left]
                left += 1
            else:
                result += rightmax- height[right]
                right -= 1
        return result