leetcode42

接雨水

解法一：动态规划

思路：只有左右两边都大于本身的位置才能存储雨水，因此可以从左往右遍历寻找每个位置左边的最大值，再从右往左遍历寻找每个位置右边的最大值，接着累加每个位置的左右最大高度值的较小值减去该位置的高度即可。

func trap(height []int) int {
    n := len(height)
    left := make([]int, n)
    right := make([]int, n)
    left[0] = height[0]
    right[n-1] = height[n-1]
    for i :=1; i< n;i++{
        left[i] = max(left[i-1],height[i])
    }
    for i:= n-2; i>=0;i--{
        right[i] = max(height[i], right[i+1])
    }
    ans :=0
    for i:=1;ib {
        return a
    }
    return b
}
func min(a, b int) int{
    if a< b{
        return a
    }
    return b
}

解法二：双指针

上述的动态规划需要额外的空间来存储每个位置的最大值，而且需要多次遍历，利用双指针可以进行优化。

定义一个左指针和一个右指针，分别从两边开始遍历，同时维护两个变量leftMax和rightMax记录每个位置的左边最大值和右边最大值。

当height[left] < height[right]时，必有leftMax

右边的同理。

func trap(height []int) int {
    left := 0
    n := len(height)
    right := n-1
    leftMax, rightMax , ans := 0,0,0
    for left < right{
        leftMax = max(leftMax, height[left])
        rightMax = max(rightMax, height[right])
        if height[left] < height[right]{
            ans += leftMax - height[left]
            left++
        }else{
            ans += rightMax - height[right]
            right--
        }
    }
    return ans
}

func max(a,b int)int{
    if a > b{
        return a
    }
    return b
}

解法三：单调栈

维护一个栈，用来存储每个位置的下标。然后遍历数组，当元素大于栈顶元素时，说明找到了一个位置使得栈中的位置可以用来存储雨水，令栈中的元素逐个出栈计算。

func trap(height []int) int {
    n := len(height)
    stack := []int{}
    ans, minH := 0, 0
    for i := 0; i< n;i++{
        for len(stack) > 0 && height[i] > height[stack[len(stack)-1]]{
            top := stack[len(stack)-1]
            stack = stack[:len(stack) -1]
            if len(stack) == 0{
                break
            }
            left := stack[len(stack)- 1]
            //栈内的元素可能大于当前元素，因此需要取最小值
            minH = min(height[left], height[i])
            ans += (i - left-1 ) * (minH - height[top]) 
        }
        stack = append(stack, i)
    }
    return ans
}

func min(a,b int)int{
    if a < b{
        return a
    }
    return b
}