代码随想录算法训练营第二十四天 | 单调栈和额外题目中的从未接触过的难题

欠债：排序学习和二分法学习

排序学习

从网上找了篇博客。
互联网大厂笔试面试必考10大排序算法

二分法学习，主要是针对有重复元素，求给定target的左右边界

应该是懂了，对于有重复元素，求给定target的左右边界的问题，要处理的细节更多一点，这里我固定一套编写风格，采用左闭右闭区间风格。牢记切记

求左边界：就是在nums[middle]=target时，让right更新，最后退出循环，左边界=right。

求右边界：就是在nums[middle]=target时，让left更新，最后退出循环，右边界=left。

最后，target值所在的左闭右闭区间就是 [ 左边界+1 ，右边界-1 ] .

单调栈

739. 每日温度

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

不会，现在还不知道单调栈是什么，直接看题解。

理解后自己尝试的代码

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        n = len(temperatures)
        result = [0]*n
        if n <= 1:
            return result

        stack = []
        stack.append(0)
        for i in range(1,n):
            
            while stack != [] and temperatures[i] > temperatures[stack[-1]]:   
                # 注意，下面这句不能这样写：
                # result[stack[-1]] = i - stack.pop()
                # 会报一个 out of index 的错            
                result[stack[-1]] = i - stack[-1]
                stack.pop()

            stack.append(i)

        return result

重点

确定好单调栈的顺序，以及当前加入元素，和栈顶元素的大小比较的所有情况。

文章没看，太长了，看了视频。

代码随想录的代码

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        answer = [0]*len(temperatures)
        stack = [0]
        for i in range(1,len(temperatures)):
            # 情况一和情况二
            if temperatures[i]<=temperatures[stack[-1]]:
                stack.append(i)
            # 情况三
            else:
                while len(stack) != 0 and temperatures[i]>temperatures[stack[-1]]:
                    answer[stack[-1]]=i-stack[-1]
                    stack.pop()
                stack.append(i)

        return answer

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

我的代码(当天晚上理解后自己编写)

496.下一个更大元素 I

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

单调栈 + 字典数据结构

lass Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        result = {}
        n = len(nums2)
        stack = []
        for i in range(0,n):
            while stack and nums2[i] > nums2[stack[-1]] :
                result[nums2[stack[-1]]] = nums2[i]
                stack.pop()
            stack.append(i)
        m = len(nums1)
        res = [-1]*m
        for i in range(m):
            if result.get(nums1[i],0):
                res[i] = result[nums1[i]]

        return res

重点

没啥可说的。

代码随想录的代码

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        result = [-1]*len(nums1)
        stack = [0]
        for i in range(1,len(nums2)):
            # 情况一情况二
            if nums2[i]<=nums2[stack[-1]]:
                stack.append(i)
            # 情况三
            else:
                while len(stack)!=0 and nums2[i]>nums2[stack[-1]]:
                    if nums2[stack[-1]] in nums1:
                        index = nums1.index(nums2[stack[-1]])
                        result[index]=nums2[i]
                    stack.pop()                 
                stack.append(i)
        return result

我的代码(当天晚上理解后自己编写)

503. 下一个更大元素 II

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

循环数组，不会处理。

重点

成环，如何判断下一个最大元素？本题思想要学习。

两个数组拼在一起，就在线性结构中模拟了成环。

但凡是成环的题，都可以用取模的方式来模拟成环后的遍历过程。

代码随想录的代码

本题的最核心代码是，将数组复制，扩充为原来的两倍，然后做顺序单调栈。

但是可以精简，进行代码优化，就是用取模操作。

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        dp = [-1] * len(nums)
        stack = []
        for i in range(len(nums)*2):
            while(len(stack) != 0 and nums[i%len(nums)] > nums[stack[-1]]):
                    dp[stack[-1]] = nums[i%len(nums)]
                    stack.pop()
            stack.append(i%len(nums))
        return dp

我的代码(当天晚上理解后自己编写)

单调递增栈，求右边第一个比当前大的元素；单调递减栈，求右边第一个比当前小的元素；求左边，倒序遍历。

在使用栈时，有弹出操作，就要判断栈是否为空

42. 接雨水

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

不会。

重点

三种解法，双指针是列向计算雨水，单调栈是横向计算雨水，利用单调栈的关键在于，想清楚，左边最近的高于当前元素的元素位置在哪里。右边的更大值，是利用单调栈获得的，左边的就在栈中，当前元素的前一个元素！

看了视频，没看文字讲解版。

双指针思想在于，先进行两次遍历，分别得到每个元素的，临近右大值数组和临近左大值数组，注意这是两个不同的数组。

代码随想录的代码

暴力解法：

class Solution:
    def trap(self, height: List[int]) -> int:
        res = 0
        for i in range(len(height)):
            if i == 0 or i == len(height)-1: continue
            lHight = height[i-1]
            rHight = height[i+1]
            for j in range(i-1):
                if height[j] > lHight:
                    lHight = height[j]
            for k in range(i+2,len(height)):
                if height[k] > rHight:
                    rHight = height[k]
            res1 = min(lHight,rHight) - height[i]
            if res1 > 0:
                res += res1
        return res

双指针：

class Solution:
    def trap(self, height: List[int]) -> int:
        leftheight, rightheight = [0]*len(height), [0]*len(height)

        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)):
            summ = min(leftheight[i],rightheight[i])-height[i]
            result += summ
        return result

单调栈

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

我的代码(当天晚上理解后自己编写)

84. 柱状图中最大的矩形

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

不会

重点

去找，每一个位置，左边和右边，第一个比当前位置矮的位置。

这里找“矮”，很关键。

有一个很关键的技巧：前后补0 。

代码随想录的代码

# 暴力解法（leetcode超时）
class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        # 从左向右遍历：以每一根柱子为主心骨（当前轮最高的参照物），迭代直到找到左侧和右侧各第一个矮一级的柱子
        res = 0

        for i in range(len(heights)):
            left = i
            right = i
            # 向左侧遍历：寻找第一个矮一级的柱子
            for _ in range(left, -1, -1):
                if heights[left] < heights[i]:
                    break
                left -= 1
            # 向右侧遍历：寻找第一个矮一级的柱子
            for _ in range(right, len(heights)):
                if heights[right] < heights[i]:
                    break
                right += 1
                
            width = right - left - 1
            height = heights[i]
            res = max(res, width * height)

        return res

# 双指针 
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

# 单调栈
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

我的代码(当天晚上理解后自己编写)

不管是，接雨水，还是求矩形最大面积，使用单调栈的核心都是：首先确定，以谁为中心，在本题就是当前遍历的元素。第二个就是，明确该中心两侧，需要的元素分别在哪！这两道题都需要左右两个元素，但是依然只需要一个单调栈，一个是当前要比较的元素，一个是栈中的上一个元素！一定要体会！

这两题的关键就是，先想清楚，如何利用 middle 值，去计算题目的要求值。学会这种，横向计算的思路。

图论 841.钥匙和房间

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

DFS

class Solution:
    def canVisitAllRooms(self, rooms: List[List[int]]) -> bool:
        n = len(rooms)
        self.visited = [False]*n
        
        idx = 0
        self.dfs(rooms,idx)
        for i in range(n):
            if self.visited[i]==False :
                return False
        return True


    def dfs(self,rooms,idx):
        if self.visited[idx]==True :
            return

        self.visited[idx] = True
        for i in rooms[idx]:
            self.dfs(rooms,i)

重点

这种题就练习一下，DFS，怎么写吧，BFS还没看。

本题的重点就是：想明白终止条件是什么（当前房间已被访问过），想明白需不需要回溯（不需要）

代码随想录的解答链接

代码随想录的代码

class Solution:
    def dfs(self, key: int, rooms: List[List[int]]  , visited : List[bool] ) :
        if visited[key] :
            return
        visited[key] = True
        keys = rooms[key]
        for i in range(len(keys)) :
            # 深度优先搜索遍历
            self.dfs(keys[i], rooms, visited)

    def canVisitAllRooms(self, rooms: List[List[int]]) -> bool:
        visited = [False for i in range(len(rooms))]

        self.dfs(0, rooms, visited)

        # 检查是否都访问到了
        for i in range(len(visited)):
            if not visited[i] :
                return False
        return True

我的代码(当天晚上理解后自己编写)

图论 127. 单词接龙

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

不会

重点

这里无向图求最短路，广搜最为合适，广搜只要搜到了终点，那么一定是最短的路径。因为广搜就是以起点中心向四周扩散的搜索。

本题如果用深搜，会比较麻烦，要在到达终点的不同路径中选则一条最短路。 而广搜只要达到终点，一定是最短路。

另外需要有一个注意点：

本题是一个无向图，需要用标记位，标记着节点是否走过，否则就会死循环！
本题给出集合是数组型的，可以转成set结构，查找更快一些

代码随想录的代码

class Solution:
    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
        wordSet = set(wordList)
        if len(wordSet)== 0 or endWord not in wordSet:
            return 0
        mapping = {beginWord:1}
        queue = deque([beginWord]) 
        while queue:
            word = queue.popleft()
            path = mapping[word]
            for i in range(len(word)):
                word_list = list(word)
                for j in range(26):
                    word_list[i] = chr(ord('a')+j)
                    newWord = "".join(word_list)
                    if newWord == endWord:
                        return path+1
                    if newWord in wordSet and newWord not in mapping:
                        mapping[newWord] = path+1
                        queue.append(newWord)                      
        return 0

我的代码(当天晚上理解后自己编写)

并查集 684. 冗余连接

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

重点

代码随想录的代码

我的代码(当天晚上理解后自己编写)

并查集 685.冗余连接II

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

重点

代码随想录的代码

我的代码(当天晚上理解后自己编写)

并查集对我来说太难了，没接触过，代码随想录也没有讲解视频，讲解的文章不够细致。先跳过吧。

模拟 31.下一个排列

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

重点

为什么排列的流程是那样的？不解

代码随想录的代码

class Solution:
    def nextPermutation(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        length = len(nums)
        for i in range(length - 2, -1, -1): # 从倒数第二个开始
            if nums[i]>=nums[i+1]: continue # 剪枝去重
            for j in range(length - 1, i, -1):
                if nums[j] > nums[i]:
                    nums[j], nums[i] = nums[i], nums[j]
                    self.reverse(nums, i + 1, length - 1)
                    return  
        self.reverse(nums, 0, length - 1)
    
    def reverse(self, nums: List[int], left: int, right: int) -> None:
        while left < right:
            nums[left], nums[right] = nums[right], nums[left]
            left += 1
            right -= 1

我的代码(当天晚上理解后自己编写)

模拟 463. 岛屿的周长

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

重点

思路一好理解，思路二不好理解，思路二注意只能计算一半，比如，左边和上边，不然就会重复。

代码随想录的代码

class Solution:
    def islandPerimeter(self, grid: List[List[int]]) -> int:

        m = len(grid)
        n = len(grid[0])

        # 创建res二维素组记录答案
        res = [[0] * n for j in range(m)]

        for i in range(m):
            for j in range(len(grid[i])):
                # 如果当前位置为水域，不做修改或reset res[i][j] = 0
                if grid[i][j] == 0:
                    res[i][j] = 0
                # 如果当前位置为陆地，往四个方向判断，update res[i][j]
                elif grid[i][j] == 1:
                    if i == 0 or (i > 0 and grid[i-1][j] == 0):
                        res[i][j] += 1
                    if j == 0 or (j >0 and grid[i][j-1] == 0):
                        res[i][j] += 1
                    if i == m-1 or (i < m-1 and grid[i+1][j] == 0):
                        res[i][j] += 1
                    if j == n-1 or (j < n-1 and grid[i][j+1] == 0):
                        res[i][j] += 1

        # 最后求和res矩阵，这里其实不一定需要矩阵记录，可以设置一个variable res 记录边长，舍矩阵无非是更加形象而已
        ans = sum([sum(row) for row in res])

        return ans

我的代码(当天晚上理解后自己编写)

位运算 1356. 根据数字二进制下 1 的数目排序

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

重点

简直是闻所未闻。

代码随想录的代码

class Solution:
    def sortByBits(self, arr: List[int]) -> List[int]:
        arr.sort(key=lambda num: (self.count_bits(num), num))
        return arr

    def count_bits(self, num: int) -> int:
        count = 0
        while num:
            num &= num - 1
            count += 1
        return count

我的代码(当天晚上理解后自己编写)