代码随想录算法训练营第48/49天|单调栈专题— 739. 每日温度、 496.下一个更大元素 I、503.下一个更大元素II、 42. 接雨水、 84.柱状图中最大的矩形

739. 每日温度

题目链接：link

1、题目描述

给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。

2、思路

单调栈（下一个更大的模板题）

3、code

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        # 单调栈:从栈首开始递增
        n = len(temperatures)
        res = [0] * n
        if n == 1:
            return res
        stack = []
        stack.append(0)
        for i in range(1,n):
            if temperatures[i] <= temperatures[stack[-1]]:
                stack.append(i)
            else:
                while len(stack)>=1 and temperatures[i]>temperatures[stack[-1]]: # 栈首元素对应的下一个更大已经找到
                    res[stack[-1]] = i - stack[-1]
                    stack.pop()
                stack.append(i)
        return res

            

4、复杂度分析

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

496. 下一个更大元素 I

题目链接：link

1、题目描述

nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置 右侧 的 第一个 比 x 大的元素。
给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。
对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 -1 。
返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的 下一个更大元素 。

2、思路

和单调栈的模板几乎是一样的，但是要搞清楚几个事情
1️⃣结果应该长啥样？
结果应该和nums1长度一致，每个元素都代表nums1对应位置的元素在nums2中的下一个更大元素
2️⃣求得是哪个集合的下一个更大元素？
实际上求的是nums2中每个元素的下一个更大元素，在找到某一个元素的下一个更大元素之后，判断这个元素是否在nums1中，在的话就记录下来

3、code

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        res = [-1] * len(nums1)
        stack = []
        stack.append(nums2[0])
        i_x = {}
        for i in range(len(nums1)):
            i_x[nums1[i]] = i
        for i in range(1,len(nums2)):
            if nums2[i] <= stack[-1]:
                stack.append(nums2[i])
            else:
                while len(stack)>=1 and nums2[i] > stack[-1]:
                    # 此时栈首元素stack[-1]的下一个更大元素为nums2[i]
                    # 判断stack[-1]是否是nums1中的元素
                    if stack[-1] in i_x.keys():
                        # 记录结果
                        res[i_x[stack[-1]]] = nums2[i]
                    stack.pop()
                stack.append(nums2[i])
        return res

4、复杂度分析

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

503. 下一个更大元素 II（循环）

题目链接：link

1、题目描述

给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素 。
数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1 。

2、思路

一般循环的思路都是拷贝一份，i = i%2

3、code

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        n = len(nums)
        res = [-1] * len(nums)
        if n == 1:
            return res
        stack = []
        stack.append(0)
        for i in range(1,n*2):
            i = i % n
            if nums[i] <= nums[stack[-1]]:
                stack.append(i)
            else:
                while len(stack)>=1 and nums[i] > nums[stack[-1]]:
                    # 此时栈首元素的下一个为nums[i]
                    res[stack[-1]] = nums[i]
                    stack.pop()
                stack.append(i)
        return res

4、复杂度分析

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

42. 接雨水（字节一面）

题目链接：link

1、题目描述

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
示例 1：

2、思路

双指针（纵向计算）

class Solution:
    def trap(self, height: List[int]) -> int:
        # 双指针：纵向计算，计算每个位置的左右最高的柱子，二者较小的作为高，这样乘上这个位置的宽度就是这个位置竖着一条的积水量
        res = 0
        n = len(height)
        if n <= 2:
            return 0
        maxleft = [0]*n
        maxright = [0]*n
        maxleft[0] = height[0]
        for i in range(1,n-1):
            maxleft[i] = max(maxleft[i-1],height[i])
        maxright[n-1] = height[n-1]
        for i in range(n-2,0,-1):
            maxright[i] = max(maxright[i+1],height[i])
        for i in range(1,n-1):
            h = max(0,min(maxleft[i],maxright[i]) - height[i])
            res += h
        return res

复杂度分析
时间复杂度：O(n)
空间复杂度：O(n)

单调栈（横向计算）

class Solution:
    def trap(self, height: List[int]) -> int:
        # 单调栈：横向计算，计算左右两个下一个更高的高度，求得就是对应位置横向一条的水量
        n = len(height)
        res = 0
        if n <= 2:
            return res
        stack = []
        stack.append(0)
        for i in range(1,n):
            if height[i] <= height[stack[-1]]:
                stack.append(i)
            else:
                while len(stack)>=1 and height[i] > height[stack[-1]]:
                    mid = stack.pop()
                    if len(stack)>=1:
                        h_left = height[stack[-1]]
                        h_mid = height[mid]
                        h_right = height[i]
                        h = max(0,min(h_left,h_right) - h_mid)
                        w = i - stack[-1] -1
                        res += h * w
                stack.append(i)
        return res        

复杂度分析
时间复杂度：O(n)
空间复杂度：O(n)

84. 柱状图中最大的矩形

题目链接：link

1、题目描述

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
求在该柱状图中，能够勾勒出来的矩形的最大面积。
示例 1：

2、代码

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        if len(heights) == 1:
            return heights[0]
        # 单调栈：求左右第一个比这个值小的元素
        heights.insert(0, 0)
        heights.append(0)
        n = len(heights)
        stack = []
        stack.append(0) # 栈里面存储下标
        res = 0
        for i in range(1,n):
            if heights[i] > heights[stack[-1]]: # 保证栈是栈首最大
                stack.append(i)
                res = max(res,heights[i])
            elif heights[i] == heights[stack[-1]]:
                stack.append(i)
                res = max(res,heights[i]*2)
            else:
                while len(stack) >= 1 and heights[i] < heights[stack[-1]]:
                    # 说明此时找到了比栈首元素对应高度更矮的高度
                    mid = stack[-1]
                    stack.pop()
                    h = heights[mid]
                    if len(stack)>=1:
                        # 找右边更矮的高度
                        right = stack[-1]
                        w = i - right - 1
                        res = max(res,h*w)
                stack.append(i)
        return res