代码随想录算法训练营第58、59天 | 739. 每日温度 496.下一个更大元素 I 503.下一个更大元素II 42. 接雨水

代码随想录系列文章目录

单调栈篇

---

---

739. 每日温度

题目链接
暴力解法，双指针，超时, 因为数据长度是100000级别的， O(n2)不好过

def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        n = len(temperatures)
        res = [0] * n
        for i in range(n):
            for j in range(i,n):
                if temperatures[j] <= temperatures[i]: continue
                else: 
                    res[i] = j-i
                    break
        return res

那么接下来在来看看使用单调栈的解法。

那有同学就问了，我怎么能想到用单调栈呢？ 什么时候用单调栈呢？

通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。

时间复杂度为O(n)。

在使用单调栈的时候首先要明确如下几点：

单调栈里存放的元素是什么？
单调栈里只需要存放元素的下标i就可以了，如果需要使用对应的元素，直接T[i]就可以获取。

单调栈里元素是递增呢？ 还是递减呢？
注意一下顺序为 从栈头到栈底的顺序，因为单纯的说从左到右或者从前到后，不说栈头朝哪个方向的话，大家一定会越看越懵。

这里我们要使用递增循序（再强调一下是指从栈头到栈底的顺序），因为只有递增的时候，加入一个元素i，才知道栈顶元素在数组中右面第一个比栈顶元素大的元素是i。

文字描述理解起来有点费劲，接下来我画了一系列的图，来讲解单调栈的工作过程。

使用单调栈主要有三个判断条件。

当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况
把这三种情况分析清楚了，也就理解透彻了。

接下来我们用temperatures = [73, 74, 75, 71, 71, 72, 76, 73]为例来逐步分析，输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

首先先将第一个遍历元素加入单调栈

加入T[1] = 74，因为T[1] > T[0]（当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况），而我们要保持一个递增单调栈（从栈头到栈底），所以将T[0]弹出，T[1]加入，此时result数组可以记录了，result[0] = 1，即T[0]右面第一个比T[0]大的元素是T[1]。
记录的是栈顶元素，比它第一个大的位置在哪

加入T[2]，同理，T[1]弹出

加入T[3]，T[3] < T[2] （当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况），加T[3]加入单调栈。

加入T[4]，T[4] == T[3] （当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况），此时依然要加入栈，不用计算距离，因为我们要求的是右面第一个大于本元素的位置，而不是大于等于！

加入T[5]，T[5] > T[4] （当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况），将T[4]弹出，同时计算距离，更新result

T[4]弹出之后， T[5] > T[3] （当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况），将T[3]继续弹出，同时计算距离，更新result

直到发现T[5]小于T[st.top()]，终止弹出，将T[5]加入单调栈

加入T[6]，同理，需要将栈里的T[5]，T[2]弹出


此时栈里只剩下了T[6]

加入T[7]， T[7] < T[6] 直接入栈，这就是最后的情况，result数组也更新完了
没有比他俩更大的了

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        n = len(temperatures)
        res = [0] * n
        stack = [0]
        for i in range(1, n):
            if temperatures[i] <= temperatures[stack[-1]]:
                stack.append(i)
            else:
                while stack and temperatures[i] > temperatures[stack[-1]]:
                    res[stack[-1]] = i - stack[-1]
                    stack.pop()
                stack.append(i)
        return res

496.下一个更大元素 I

题目链接
这道题和上一道题基本是一样的，找的都是下一个更大的元素
单调栈里的顺序都是递增的顺序，有两个区别，1是上一题找的是数组下标这道题找的是数值，2是这道题找的是nums1中的元素在nums2中对应的数字的下一个更大的

我们的res数组要开辟成nums1的大小，在遍历nums2的过程中，我们要判断nums2[i]是否在nums1中出现过，因为最后是要根据nums1元素的下标来更新result数组。

具体来说，我们还是比较每个元素和栈顶元素的大小，要维护一个递增的单调栈，小于等于栈顶的元素我们都直接把它们入栈，直到遇到大于栈顶的元素

当遇到大于栈顶的元素时，如果栈顶元素也在nums1中，那么我们就可以更新res数组里对应位置的值了；我们需要获取一下该栈顶元素在nums1的索引，此索引也就是它在res中的对应的位置，然后更新它的res值

当遇到大于栈顶的元素时，我们需要把栈顶pop出来，再比较下一个栈顶，如果依然是当前元素大于它的话，我们就一直pop，这也是为什么用 while stack and nums[i] > stack[-1]的原因；直到栈里没有比当前元素大的了，我们把当前元素入栈

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        m, n = len(nums1), len(nums2)
        res = [-1] * m
        stack = [nums2[0]]

        for i in range(1, n):
            if nums2[i] <= stack[-1]:
                stack.append(nums2[i])
            else:
                while stack and nums2[i] > stack[-1]:
                    if stack[-1] in nums1:
                        index = nums1.index(stack[-1])
                        res[index] = nums2[i]
                    stack.pop()
                stack.append(nums2[i])
        return res

503.下一个更大元素II

题目链接

这道题的难点就是在于，大小的比较可以循环，从左边再比较
注意，可不是仅最后一个元素可以从数组的左边开始再比较，是所有的数（除了第一个）都可以从数组左边再比较

因此，一定需要把数组拼成两倍长，然后再用单调栈去做
res数组还是单倍长，更新位置的话用i%n 单倍长就行了

总结
如何处理循环数组。
相信不少同学看到这道题，就想那我直接把两个数组拼接在一起，然后使用单调栈求下一个最大值不就行了！
确实可以！
把两个nums数组拼接在一起，使用单调栈计算出每一个元素的下一个最大值，就是答案

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        n = len(nums)
        res = [-1] * n 
        stack = [0]

        for i in range(1, n*2):
            while stack and nums[i%n] > nums[stack[-1]]:
                res[stack[-1]] = nums[i%n]    
                stack.pop()
            stack.append(i%n)
            
        return res
        

42.接雨水

题目链接
接雨水问题在面试中还是常见题目的，有必要好好学一学

双指针解法

首先双指针我们要明白是按行计算还是按列计算，按列计算好理解

如果按照列来计算的话，宽度一定是1了，我们再把每一列的雨水的高度求出来就可以了
首先第一列和最后一列是不参与运算的，记得跳过

每一列雨水的高度，取决于，该列 左侧最高的柱子和右侧最高的柱子中最矮的那个柱子的高度。即 min(lheight, rheight) 如求列4的雨水

列4左侧最高是2，右侧最高高3，两者取min,是2；(2-1) * 1就是它接雨水的量

一样的方法，只要从头遍历一遍所有的列，然后求出每一列雨水的体积，相加之后就是总雨水的体积了。

首先从头遍历所有的列，并且要注意第一个柱子和最后一个柱子不接雨水，代码如下：
时间复杂度O(n), 力扣会超时

class Solution:
    def trap(self, height: List[int]) -> int:
        n = len(height)
        sum = 0
        for i in range(n):
            if i == 0 or i == n-1: continue
            lheigh, riheigh = height[i], height[i]
            for l in range(i-1, -1, -1):
                if height[l] > lheigh: lheigh = height[l]
            for r in range(i+1, n):
                if height[r] > riheigh: riheigh = height[r]
            h = min(lheigh, riheigh) - height[i]
            if h > 0: sum += h*1
        return sum 

dp解法

在上面的双指针解法中，我们其实能感受到，在计算左边最大高度和右边最大高度的时候，有很多重复的运算

我们可以用dp数组把每一个位置的左边最大高度和右边最大的高度记录下来，这样就起到拿空间换时间的作用了；那么怎么去得到这样两个数组呢

从左向右遍历，记录一下当前位置左边最大高度，当前位置就变成下一个位置的左边最大高度了

 maxLeft[0] = height[0];
        for (int i = 1; i < size; i++) {
            maxLeft[i] = max(height[i], maxLeft[i - 1]);

同理，从右向左遍历

maxRight[size - 1] = height[size - 1];
        for (int i = size - 2; i >= 0; i--) {
            maxRight[i] = max(height[i], maxRight[i + 1]);

代码如下：

def trap(self, height: List[int]) -> int:
        n = len(height)
        leftheight, rightheight = [0] * n, [0] * n
        
        leftheight[0]=height[0]
        for i in range(1,len(height)):
            leftheight[i]=max(leftheight[i-1],height[i])
        rightheight[-1]=height[-1]
        for i in range(len(height)-2,-1,-1):
            rightheight[i]=max(rightheight[i+1],height[i])
        
        result = 0
        for i in range(0,len(height)):
            h = min(leftheight[i],rightheight[i])-height[i]
            if h > 0: result += h
        return result

单调栈解法

要先准备明白几个问题
1.单调栈内元素的顺序：

从栈头（元素从栈头弹出）到栈底的顺序应该是从小到大的顺序。

因为一旦发现添加的柱子高度大于栈头元素了，此时就出现凹槽了，栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，而添加的元素就是凹槽右边的柱子。

2.遇到相同高度的柱子怎么办
遇到相同的元素，更新栈内下标，就是将栈里元素（旧下标）弹出，将新元素（新下标）加入栈中。

例如 5 5 1 3 这种情况。如果添加第二个5的时候就应该将第一个5的下标弹出，把第二个5添加到栈中。

因为我们要求宽度的时候 如果遇到相同高度的柱子，需要使用最右边的柱子来计算宽度。

3.栈里要保存什么数值
是用单调栈，其实是通过 长 * 宽 来计算雨水面积的。

长就是通过柱子的高度来计算，宽是通过柱子之间的下标来计算，

那么栈里有没有必要存一个pair类型的元素，保存柱子的高度和下标呢。

其实不用，栈里就存放下标就行了，想要知道对应的高度，通过height[stack.top()] 就知道弹出的下标对应的高度了。

单调栈具体的处理逻辑

先将下标0的柱子加入到栈中，st.push(0);。

然后开始从下标1开始遍历所有的柱子，for (int i = 1; i < height.size(); i++)。

如果当前遍历的元素（柱子）高度小于栈顶元素的高度，就把这个元素加入栈中，因为栈里本来就要保持从小到大的顺序（从栈头到栈底）。

if (height[i] < height[st.top()])  st.push(i);

如果当前遍历的元素（柱子）高度等于栈顶元素的高度，要跟更新栈顶元素，因为遇到相相同高度的柱子，需要使用最右边的柱子来计算宽度。

if (height[i] == height[st.top()]) { // 例如 5 5 1 7 这种情况
  st.pop();
  st.push(i);
}

如果当前遍历的元素（柱子）高度大于栈顶元素的高度，此时就出现凹槽了，如图所示：

取栈顶元素，将栈顶元素弹出，这个就是凹槽的底部，也就是中间位置，下标记为mid，对应的高度为height[mid]（就是图中的高度1）。

此时的栈顶元素st.top()，就是凹槽的左边位置，下标为st.top()，对应的高度为height[st.top()]（就是图中的高度2）。

当前遍历的元素i，就是凹槽右边的位置，下标为i，对应的高度为height[i]（就是图中的高度3）。

此时大家应该可以发现其实就是栈顶和栈顶的内侧的一个元素以及要入栈的三个元素来接水！

那么雨水高度是 min(凹槽左边高度, 凹槽右边高度) - 凹槽底部高度，代码为：int h = min(height[st.top()], height[i]) - height[mid];

雨水的宽度是 凹槽右边的下标 - 凹槽左边的下标 - 1（因为只求中间宽度），代码为：int w = i - st.top() - 1 ;

当前凹槽雨水的体积就是：h * w。

while (!st.empty() && height[i] > height[st.top()]) { // 注意这里是while，持续跟新栈顶元素
    int mid = st.top();
    st.pop();
    if (!st.empty()) {
        int h = min(height[st.top()], height[i]) - height[mid];
        int w = i - st.top() - 1; // 注意减一，只求中间宽度
        sum += h * w;
    }
}

代码如下：

def trap(self, height: List[int]) -> int:
        n = len(height)
        stack = [0]
        sum_ = 0

        for i in range(1,n):
            if height[i] < height[stack[-1]]:
                stack.append(i)
            elif height[i] == height[stack[-1]]:
                stack.pop()
                stack.append(i)
            else:
                while stack and height[i] > height[stack[-1]]:
                    mid = stack[-1]
                    stack.pop()
                    if stack:
                        h = min(height[stack[-1]], height[i]) - height[mid]
                        w = i - stack[-1] - 1
                        sum_ += h*w
                stack.append(i)
        return sum_

注意，栈内装的是索引，比较的时候要 height[i] > height[stack[-1]]