每日温度

未看解答自己编写的青春版

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

重点

每日温度

1、对比用while

2、单调栈里存下标即可

3、求右边第一个更大，所以是单调递增栈，指的是：从栈顶到栈底，顺序是单增，栈顶是弹出和加入元素的位置。

题解的代码

日后再次复习重新写

下一个更大元素 I

未看解答自己编写的青春版

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        n = len(nums2)
        res = [-1]*n
        # stack还是得存下标，存数，不方便索引到res结果数组
        stack = [0]
        for i in range(1,n):
            while stack != [] and nums2[i] > nums2[stack[-1]] :
                idx = stack.pop()
                res[idx] = nums2[i]
            stack.append(i)
        m = len(nums1)
        result = [-1]*m
        for i in range(m):
            temp = nums2.index(nums1[i])
            result[i] = res[temp]
        return result

重点

同上一题。找索引用 list.index()

下一个更大元素 I

题解的代码

日后再次复习重新写

下一个更大元素II

未看解答自己编写的青春版

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        n = len(nums)
        res = [-1]*n
        stack = [0]
        for i in range(1,2*n):
            temp = i % n
            while stack != [] and nums[temp] > nums[stack[-1]] :
                j = stack.pop()
                # 注意看，我们对每个进入stack，单调栈的元素，都做了对n的取模处理
                # 所以这里pop出来的 j ，一定是好的，不需要经过处理就可以对结果数组赋值
                res[j] = nums[temp]
            stack.append(temp)
        return res
        

重点

本题需要处理的就是，循环数组，的情况。

朴实的想法是：把目标数组复制一倍，将目标数组扩容为两倍，然后对这个两倍的数组做最原始的单调栈。

可以进一步优化：在索引循环时，循环到 2*n , 但是对于每个 i ，对 i 进行对数组长度 n 的取模操作。

题解的代码

日后再次复习重新写

接雨水

未看解答自己编写的青春版

class Solution:
    def trap(self, height: List[int]) -> int:
        total = 0
        n = len(height)
        # 栈里放的是索引
        stack = [0]
        for i in range(1,n):  
            temp = 0
            while stack != [] and height[i] > 0 and height[i] >= height[stack[-1]] :
                j = stack.pop()
                total += (height[j]-temp)*(i-j-1)
                temp = height[j]
            # 这个判断是为了处理，中间有矮柱，或者空的情况，但是是我根据错误示例发现的，没什么道理啊
            # 简单举例为：[4,2,1,3] [4,0,0,3] 不加下面的判断，就会漏掉4和3之间的部分
            if stack != [] and height[i] < height[stack[-1]] :
                total += (height[i]-temp)*(i-stack[-1]-1)
            
            if height[i] > 0 :
                stack.append(i)
            
        return total

重点

这题要看题解，自己写的代码中，加入的一段逻辑，是为了AC而加的，如果不是题目有错误示例，我想不到。

接雨水

还是觉得，卡哥的题解给的方法是自然的，按我的方法，第一次确实想不到这种要单独处理的情况。而且不让0入栈，是比较牵强的。

本题还有一个要注意的是：如果两个数值相等，怎么处理？照常入栈，顶替掉前一个！

题解的代码

class Solution:
    def trap(self, height: List[int]) -> int:
        # 单调栈
        '''
        单调栈是按照 行 的方向来计算雨水
        从栈顶到栈底的顺序：从小到大
        通过三个元素来接水：栈顶，栈顶的下一个元素，以及即将入栈的元素
        雨水高度是 min(凹槽左边高度, 凹槽右边高度) - 凹槽底部高度
        雨水的宽度是 凹槽右边的下标 - 凹槽左边的下标 - 1（因为只求中间宽度）
        '''
        # stack储存index，用于计算对应的柱子高度
        stack = [0]
        result = 0
        for i in range(1, len(height)):
            # 情况一
            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_height = height[stack[-1]]
                    stack.pop()
                    if stack:
                        right_height = height[i]
                        left_height = height[stack[-1]]
                        # 两侧的较矮一方的高度 - 凹槽底部高度
                        h = min(right_height, left_height) - mid_height
                        # 凹槽右侧下标 - 凹槽左侧下标 - 1: 只求中间宽度
                        w = i - stack[-1] - 1
                        # 体积：高乘宽
                        result += h * w
                stack.append(i)
        return result

# 单调栈压缩版
class Solution:
    def trap(self, height: List[int]) -> int:
        stack = [0]
        result = 0
        for i in range(1, len(height)):
            while stack and height[i] > height[stack[-1]]:
                mid_height = stack.pop()
                if stack:
                    # 雨水高度是 min(凹槽左侧高度, 凹槽右侧高度) - 凹槽底部高度
                    h = min(height[stack[-1]], height[i]) - height[mid_height]
                    # 雨水宽度是 凹槽右侧的下标 - 凹槽左侧的下标 - 1
                    w = i - stack[-1] - 1
                    # 累计总雨水体积
                    result += h * w
            stack.append(i)
        return result

按题解风格重写

class Solution:
    def trap(self, height: List[int]) -> int:
        total = 0
        n = len(height)
        # 栈里放的是索引
        stack = [0]
        for i in range(1,n):  
            
            while stack != [] and height[i] >= height[stack[-1]] :
                mid = stack.pop()
                if stack != []:
                    left = stack[-1]
                    total += (min(height[left],height[i])-height[mid])*(i-left-1)
                
            stack.append(i)
            
        return total

日后再次复习重新写

柱状图中最大的矩形

未看解答自己编写的青春版

没有思路，主要难点在于，不知道怎样计算最大矩形面积合适。包括上一道题一样，一开始也是不晓得怎样计算雨水面积合适（比如上一道题，按照单调栈计算，是按照行来计算的）。

本题计算矩形面积的方式：依旧按照上一题接雨水的思路，采取横向计算的方式！对于当前遍历的位置 i ，取当前位置的高度为合并矩形的高度，向左向右遍历，找到左右两边第一个比此高度底的位置，面积就等于高X宽。

单调栈没思路的时候，先用暴力解法试试。

暴力法：超时

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        maxarea = 0
        n = len(heights)
        for i in range(n):
            h = heights[i]
            left = i-1
            right = i+1
            while left > -1 :
                if heights[left] < heights[i] :
                    break
                left -= 1
            while right < n :
                if heights[right] < heights[i] :
                    break
                right += 1
            temp = h * (right-left-1)
            maxarea = max(maxarea,temp)
        return maxarea 

DP法（二维数组提前存储每个位置的第一个左边小于当前高度的下标，第一个右边小于当前高度的下标）。超时。（在本题中，DP法和双指针法相同了，DP也无法用递推公式，都是用两个一维数组去提前存储，而且都需要循环去搜索。）

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        maxarea = 0
        n = len(heights)
        dp = [[0]*2 for _ in range(n)]
        dp[0][0] = -1
        dp[n-1][1] = n
        # 注意本题与前一题接雨水的不同，前一题因为在用暴力法(DP，双指针)都是采用列向计算
        # 所以在计算左右临近最大时，可以使用迭代
        # 本题因为是求左右临近最小，用提前记忆的方法，依然需要循环！
        for i in range(1,n):
            j = i
            while j > 0 and heights[i] <= heights[j-1]:
                j = j-1
            dp[i][0] = j-1
        for i in range(n-2,-1,-1):
            j = i
            while j < n-1 and heights[i] <= heights[j+1]:
                j = j+1
            dp[i][1] = j+1
        
        for i in range(n):
            h = heights[i]
            left = dp[i][0]
            right = dp[i][1] 
            temp = h * (right-left-1)
            maxarea = max(maxarea,temp)
        return maxarea 

卡哥的双指针法竟然不超时？为什么

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        size = len(heights)
        # 两个DP数列储存的均是下标index
        min_left_index = [0] * size
        min_right_index = [0] * size
        result = 0

        # 记录每个柱子的左侧第一个矮一级的柱子的下标
        min_left_index[0] = -1  # 初始化防止while死循环
        for i in range(1, size):
            # 以当前柱子为主心骨，向左迭代寻找次级柱子
            temp = i - 1
            while temp >= 0 and heights[temp] >= heights[i]:
                # 当左侧的柱子持续较高时，尝试这个高柱子自己的次级柱子（DP
                temp = min_left_index[temp]
            # 当找到左侧矮一级的目标柱子时
            min_left_index[i] = temp
        
        # 记录每个柱子的右侧第一个矮一级的柱子的下标
        min_right_index[size-1] = size  # 初始化防止while死循环
        for i in range(size-2, -1, -1):
            # 以当前柱子为主心骨，向右迭代寻找次级柱子
            temp = i + 1
            while temp < size and heights[temp] >= heights[i]:
                # 当右侧的柱子持续较高时，尝试这个高柱子自己的次级柱子（DP
                temp = min_right_index[temp]
            # 当找到右侧矮一级的目标柱子时
            min_right_index[i] = temp
        
        for i in range(size):
            area = heights[i] * (min_right_index[i] - min_left_index[i] - 1)
            result = max(area, result)
        
        return result

明白了，在循环找左右临近最小时，不需要一个下标一个下标地去遍历，可以利用已经算好的值进行跳跃！！！

在上面原代码的基础上进行的修改，但是由于上面那一版没想到这些，用的下标是和 j-1 / j+1 比较的，简直是下标灾难！

这个代码能过，但是时间和空间上只打败了 5% 。

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        maxarea = 0
        n = len(heights)
        dp = [[0]*2 for _ in range(n)]
        dp[0][0] = -1
        dp[n-1][1] = n
        # 注意本题与前一题接雨水的不同，前一题因为在用暴力法(DP，双指针)都是采用列向计算
        # 所以在计算左右临近最大时，可以使用迭代
        # 本题因为是求左右临近最小，用提前记忆的方法，依然需要循环！
        for i in range(1,n):
            j = i
            # 下标灾难
            while j > 0 and heights[i] <= heights[j-1]:
                # index要减一，dp出来的值要加一，因为上面的判断，是和减一的位置判断的
                j = dp[j-1][0]+1
            dp[i][0] = j-1
        for i in range(n-2,-1,-1):
            j = i
            while j < n-1 and heights[i] <= heights[j+1]:
                # index要加一，dp出来的值要减一，因为上面的判断，是和加一的位置判断的
                j = dp[j+1][1]-1
            dp[i][1] = j+1
        
        for i in range(n):
            h = heights[i]
            left = dp[i][0]
            right = dp[i][1] 
            temp = h * (right-left-1)
            maxarea = max(maxarea,temp)
        return maxarea 

不用该死的 j-1 / j+1 了，重新更改下标！

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        maxarea = 0
        n = len(heights)
        dp = [[0]*2 for _ in range(n)]
        dp[0][0] = -1
        dp[n-1][1] = n
        # 注意本题与前一题接雨水的不同，前一题因为在用暴力法(DP，双指针)都是采用列向计算
        # 所以在计算左右临近最大时，可以使用迭代
        # 本题因为是求左右临近最小，用提前记忆的方法，依然需要循环！
        for i in range(1,n):
            j = i-1
            while j > -1 and heights[i] <= heights[j]:     
                j = dp[j][0]
            dp[i][0] = j
        for i in range(n-2,-1,-1):
            j = i+1
            while j < n and heights[i] <= heights[j]:   
                j = dp[j][1]
            dp[i][1] = j
        
        for i in range(n):
            h = heights[i]
            left = dp[i][0]
            right = dp[i][1] 
            temp = h * (right-left-1)
            maxarea = max(maxarea,temp)
        return maxarea 

更改后，下标看起来顺眼多了，但是还是都只打败了5%，why ?

将二维dp数组，拆为了两个一维数组。

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        maxarea = 0
        n = len(heights)
        # 初始化一起做了
        dp1 = [-1]*n
        dp2 = [n]*n
        
        # 注意本题与前一题接雨水的不同，前一题因为在用暴力法(DP，双指针)都是采用列向计算
        # 所以在计算左右临近最大时，可以使用迭代
        # 本题因为是求左右临近最小，用提前记忆的方法，依然需要循环！
        for i in range(1,n):
            j = i-1
            while j > -1 and heights[i] <= heights[j]:     
                j = dp1[j]
            dp1[i] = j
        for i in range(n-2,-1,-1):
            j = i+1
            while j < n and heights[i] <= heights[j]:   
                j = dp2[j]
            dp2[i] = j
        
        for i in range(n):
            h = heights[i]
            left = dp1[i]
            right = dp2[i]
            temp = h * (right-left-1)
            maxarea = max(maxarea,temp)
        return maxarea 

啪的一下，很快啊，就打败40%了！

这道题因为必须横向计算面积，没有列向计算的方法，所以我认为，没有像上一题，接雨水那样，具有显著风格的双指针方法。

单调栈方法，这道题因为要求左右最小临近，所以是递减栈。

这道题的边界情况不好处理我觉得，左边的情况可以通过while里加判断解决。右边的情况，目前我认为只能在for循环结束后，单独再去弹出栈来计算了。我感觉不如对heights数组，左右加0。看看卡哥的写法

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        maxarea = 0
        # 这道题的边界情况不好处理我觉得，左边的情况可以通过while里加判断解决
        # 右边的情况，目前我认为只能在for循环结束后，单独再去弹出栈来计算了
        # 我感觉不如对heights数组，左右加0
        
        heights = [0]+heights+[0]
        n = len(heights)
        stack = [0]
        for i in range(1,n):
            while stack != [] and heights[i] < heights[stack[-1]]:
                temp = stack.pop()
                if stack != [] :
                    left = stack[-1]
                    j = heights[temp]*(i-left-1)
                    maxarea = max(maxarea,j)
            stack.append(i)
        return maxarea

重点

接雨水 (opens new window)是找每个柱子左右两边第一个大于该柱子高度的柱子，而本题是找每个柱子左右两边第一个小于该柱子的柱子。

这里就涉及到了单调栈很重要的性质，就是单调栈里的顺序，是从小到大还是从大到小。

在接雨水 (opens new window)中，单调栈从栈头（元素从栈头弹出）到栈底的顺序应该是从小到大的顺序。

因为本题是要找每个柱子左右两边第一个小于该柱子的柱子，所以从栈头（元素从栈头弹出）到栈底的顺序应该是从大到小的顺序。

题解的代码

啊哈，也是通过前后补0做的，合理。

# 单调栈
class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        # Monotonic Stack
        '''
        找每个柱子左右侧的第一个高度值小于该柱子的柱子
        单调栈：栈顶到栈底：从大到小（每插入一个新的小数值时，都要弹出先前的大数值）
        栈顶，栈顶的下一个元素，即将入栈的元素：这三个元素组成了最大面积的高度和宽度
        情况一：当前遍历的元素heights[i]大于栈顶元素的情况
        情况二：当前遍历的元素heights[i]等于栈顶元素的情况
        情况三：当前遍历的元素heights[i]小于栈顶元素的情况
        '''

        # 输入数组首尾各补上一个0（与42.接雨水不同的是，本题原首尾的两个柱子可以作为核心柱进行最大面积尝试
        heights.insert(0, 0)
        heights.append(0)
        stack = [0]
        result = 0
        for i in range(1, len(heights)):
            # 情况一
            if heights[i] > heights[stack[-1]]:
                stack.append(i)
            # 情况二
            elif heights[i] == heights[stack[-1]]:
                stack.pop()
                stack.append(i)
            # 情况三
            else:
                # 抛出所有较高的柱子
                while stack and heights[i] < heights[stack[-1]]:
                    # 栈顶就是中间的柱子，主心骨
                    mid_index = stack[-1]
                    stack.pop()
                    if stack:
                        left_index = stack[-1]
                        right_index = i
                        width = right_index - left_index - 1
                        height = heights[mid_index]
                        result = max(result, width * height)
                stack.append(i)
        return result

# 单调栈精简
class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        heights.insert(0, 0)
        heights.append(0)
        stack = [0]
        result = 0
        for i in range(1, len(heights)):
            while stack and heights[i] < heights[stack[-1]]:
                mid_height = heights[stack[-1]]
                stack.pop()
                if stack:
                    # area = width * height
                    area = (i - stack[-1] - 1) * mid_height
                    result = max(area, result)
            stack.append(i)
        return result

日后再次复习重新写

一段用于复制的标题

未看解答自己编写的青春版

重点

题解的代码

日后再次复习重新写

一段用于复制的标题

未看解答自己编写的青春版

重点

题解的代码

日后再次复习重新写

一段用于复制的标题

未看解答自己编写的青春版

重点

题解的代码

日后再次复习重新写