研习代码 day51 | 单调栈问题（2）

一、下一个更大元素 II

        1.1 题目

        给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素 。

        数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1 。

示例 1:

输入: nums = [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数； 
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

示例 2:

输入: nums = [1,2,3,4,3]
输出: [2,3,4,-1,4]

提示:

• 1 <= nums.length <= 10^4
• -10^9 <= nums[i] <= 10^9

        1.2 题目链接

        503.下一个更大元素

        1.3 解题思路和过程想法

        （1）解题思路

        分析：要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置--->单调栈
        思路：遍历数组，当“单调栈”为空 或 当前元素小于栈顶元素时，将当前元素的下标压栈；当前元素大于栈顶元素时，栈顶元素对应的目标元素就是当前元素，赋值当前元素的下标值即可。
        亮点：为能实现循环搜索，将遍历长度变成 2 * length -1，筛选两遍；因为直接将遍历下标带入数组会越界，所以需要进行取模操作
        注：过程中也有担心会不会被覆盖，但是在自己手动推导后发现并不会，无非是再次处理在第一轮中就已经处理过的元素，最终的答案还是一样的   

        （2）过程想法

        遍历两次的思路其实是比较好想，当然也可以用一个数组存储 2 遍数组，然后再照旧操作

        1.4 代码

        1.4.1 遍历两次

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        length = len(nums)

        result = [-1] * length
        stack = []

        for i in range(length*2-1):
            if len(stack) == 0 or nums[i%length] <= nums[stack[-1]]:
                stack.append(i%length)
            else:
                while len(stack) and nums[i%length] > nums[stack[-1]]:
                    result[stack[-1]] = nums[i%length]
                    stack.pop()
                stack.append(i%length)

        return result

        # 5  4  3  2  1
        # -1 5  5  5  5  

二、接雨水

        2.1 题目

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

        2.2 题目链接

        42.接雨水

        2.3 解题思路和过程想法

        （1）解题思路

                分析： # 第一列和最后一列不计入计算
                纵向加和：当前列雨水高度 = 左右两侧最高的柱子中较低的那个柱子 - 当前柱子的高度 
                                 result += 当前列雨水高度
                横向加和：高度 =   当前柱子左右两侧第一个更大的元素中较小值 - 当前柱子的高度
                                  宽度 = | 当前柱子左右两侧第一个更大的元素中较小值的下标 - 当前下标 |
                                  result += 高度 * 宽度

        （2）过程想法

        暴力解法更好构思，单调栈的方法要多思考一会

        2.4 代码

        2.4.1 暴力解法（纵向求和）

class Solution:
    def trap(self, height: List[int]) -> int:
        # 求左右两侧最高的柱子中较低的那个柱子 - 当前柱子的高度 = 当前列中雨水的高度
        # 第一列和最后一列不计入计算
        width = len(height)
        res = 0

        for i in range(1, width-1):
            leftMax = height[i]     # 左边最高的柱子
            rightMax = height[i]    # 右边最高的柱子

            for left in range(0,i):
                if height[left] > leftMax:
                    leftMax = height[left]
                
            for right in range(i+1, width):
                if height[right] > rightMax:
                    rightMax = height[right]

            res += min(leftMax,rightMax) - height[i]    # 计算当前柱子积累的雨水高度

        return res       

        2.4.2 优化的暴力解法

class Solution:
    def trap(self, height: List[int]) -> int:
        # 求左右两侧最高的柱子中较低的那个柱子 - 当前柱子的高度 = 当前列中雨水的高度
        # 第一列和最后一列不计入计算
        width = len(height)

        if width <= 2:
            return 0
        
        res = 0
        leftMax  = [0] * width     # 左边最高的柱子
        rightMax = [0] * width     # 右边最高的柱子

        leftMax[0] = height[0]
        for i in range(1,width-1):
            leftMax[i] = max(height[i], leftMax[i-1])

        rightMax[width-1] = height[width-1]   
        for i in range(width-2, 0, -1):
            rightMax[i] = max(height[i], rightMax[i+1])
        
        for i in range(1, width-1):   
            if min(leftMax[i],rightMax[i]) - height[i] > 0:
                res += min(leftMax[i],rightMax[i]) - height[i]    # 计算当前柱子积累的雨水高度

        return res       

        2.4.3 单调栈(横向求和)

class Solution:
    def trap(self, height: List[int]) -> int:
        # 高度 =   当前柱子左右两侧第一个更大的元素中较小值 - 当前柱子的高度
        # 宽度 = | 当前柱子左右两侧第一个更大的元素中较小值的下标 - 当前下标 |
        # result += 高度 * 宽度
        # 第一列和最后一列不计入计算

        width = len(height)

        if width <= 2:
            return 0
        
        res = 0
        stack = [0]

        for i in range(1, width):
            if len(stack) == 0 or height[i] <= height[stack[-1]]:
                stack.append(i)
            else:
                while len(stack) and height[i] > height[stack[-1]]:
                    mid = height[stack[-1]]
                    stack.pop()
                    if len(stack):
                        leftMax = height[stack[-1]]
                        rightMax = height[i]
                        h = min(leftMax, rightMax) - mid
                        w = i - stack[-1] - 1 if leftMax < rightMax else i - stack[-1] - 1
                        res += h * w      
                stack.append(i)

        return res