83-89

83： 删除重复元素 剩一个  依旧头结点

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if head == None:
            return None
        headtemp = ListNode(val=head.val-1,next=head)
        p = headtemp
        r = headtemp
        while p.next != None:
            if p.next.val != p.val:
                r.next = p.next
                r = r.next
            p = p.next
        r.next = None
        return headtemp.next


作者：yizhu-jia
链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/solution/wu-yu-ning-ye-tou-jie-dian-zhen-hao-yong-l4kr/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

84

柱状图中最大矩形  

我看到就想到了接雨水

单调栈  但没想到单调栈的用法  

这道题就是说 对于每一个矩形 向左向右都找到以他为高的 最宽的那个矩形 并记录面积  怎么找 单调栈 

    #思路  对于每一个下标  判断从他开始并以他为高的矩形  左右最多能到哪   也就是求这个矩形的长度
    #所以  比如有数组有十个数  就会得到十个长度   再乘以他们各自的高度  得到十个面积  返回最高的就行
怎么找呢 单调栈 维持一个递增的栈 如果栈顶比我当前的还要高 说明可以加进我当前的矩形中 出栈继续往前看 找到那个比自己低的 作为左边界
同时 出栈意味着 当前的i是栈顶右边第一个比栈顶低的位置 i就成为了栈顶的右边界

不管咋样 最后当前元素入栈

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:

        m = len(heights)
        monostack = []
        left = [-2] * m
        right = [-2] * m
        for i in range(m):
            if monostack == []:
                left[i] = -1
            elif  heights[monostack[-1]] >= heights[i] :
                while heights[monostack[-1]] >= heights[i]:
                    temp = monostack.pop()
                    right[temp] = i
                    if monostack == []:
                        break
                if monostack == []:
                    left[i] = -1
                else:
                    left[i] = monostack[-1]
            else:
                left[i] = monostack[-1]
            monostack.append(i)
        while monostack != []:
            right[monostack.pop()] = m
        return max((right[i]-left[i]-1)*heights[i] for i in range(m))




作者：yizhu-jia
链接：https://leetcode-cn.com/problems/largest-rectangle-in-histogram/solution/zhong-yu-kan-dong-da-an-liao-by-yizhu-ji-za6v/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

85 

把这个列表压下来  压到每一行去  每一行就是一个上题的问题

class Solution:
    def maximalRectangle(self, matrix: List[List[str]]) -> int:
        def largestRectangleArea(heights):
            #思路  对于每一个下标  判断从他开始并以他为高的矩形  左右最多能到哪   也就是求这个矩形的长度
            #所以  比如有数组有十个数  就会得到十个长度   再乘以他们各自的高度  得到十个面积  返回最高的就行
            m = len(heights)
            monostack = []
            left = [-2] * m
            right = [-2] * m
            for i in range(m):
                if monostack == []:
                    left[i] = -1
                elif  heights[monostack[-1]] >= heights[i] :
                    while heights[monostack[-1]] >= heights[i]:
                        temp = monostack.pop()
                        right[temp] = i
                        if monostack == []:
                            break
                    if monostack == []:
                        left[i] = -1
                    else:
                        left[i] = monostack[-1]
                else:
                    left[i] = monostack[-1]
                monostack.append(i)
            while monostack != []:
                right[monostack.pop()] = m
            return max((right[i]-left[i]-1)*heights[i] for i in range(m))


        if matrix== [] or matrix == [[]]:
            return 0
        m = len(matrix)
        n = len(matrix[0])
        top = [[0]*n for i in range(m)]
        for j in range(n):
            if matrix[0][j] == '1':
                top[0][j] = 1
        for i in range(1,m):
            for j in range(n):
                if matrix[i][j] == '0':
                    top[i][j] = 0
                else:
                    top[i][j] = top[i-1][j] +1
        return max(largestRectangleArea(top[i]) for i in range(m))

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/maximal-rectangle/solution/hao-jia-huo-wo-zhi-jie-ba-shang-dao-ti-b-50d6/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

86  分割链表 

两个头结点 一个接收小的 一个接收大的
最后拼起来

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def partition(self, head: ListNode, x: int) -> ListNode:
            headnode1 = ListNode(val= None,next= None)
            headnode2 = ListNode(val= None,next= None)
            r1 = headnode1
            r2 = headnode2
            p = head
            while p != None:
                if p.val < x:
                    r1 .next = p
                    r1 = r1.next
                else:
                    r2.next = p
                    r2 = r2.next
                p = p.next
            r2.next = None
            r1.next = headnode2.next
            return headnode1.next


作者：yizhu-jia
链接：https://leetcode-cn.com/problems/partition-list/solution/wu-xian-zhan-yong-kong-jian-by-yizhu-jia-0sjw/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

87  扰乱字符串 

判断左右  我以为不会这么复杂的 

用一个字典来记录出现字母是否相同

我是CV工程师

class Solution:
    def isScramble(self, s1: str, s2: str) -> bool:
        @cache
        def dfs(i1: int, i2: int, length: int) -> bool:
            """
            第一个字符串从 i1 开始，第二个字符串从 i2 开始，子串的长度为 length，是否和谐
            """

            # 判断两个子串是否相等
            if s1[i1:i1+length] == s2[i2:i2+length]:
                return True
            
            # 判断是否存在字符 c 在两个子串中出现的次数不同
            if Counter(s1[i1:i1+length]) != Counter(s2[i2:i2+length]):
                return False
            
            # 枚举分割位置
            for i in range(1, length):
                # 不交换的情况
                if dfs(i1, i2, i) and dfs(i1 + i, i2 + i, length - i):
                    return True
                # 交换的情况
                if dfs(i1, i2 + length - i, i) and dfs(i1 + i, i2, length - i):
                    return True
        
            return False

        ans = dfs(0, 0, len(s1))
        dfs.cache_clear()
        return ans

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/scramble-string/solution/cvgong-cheng-shi-by-yizhu-jia-f5bg/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

88

合并有序数组  

归并嘛

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        nums3 = []
        i = 0
        j = 0
        while i < m and j < n :
            if nums1[i] <= nums2[j]:
                nums3.append(nums1[i])
                i += 1
            else:
                nums3.append(nums2[j])
                j += 1
        if i != m:
            nums3.extend(nums1[i:m])
        else:
            nums3.extend((nums2[j:n]))
        for i in range(m+n):
            nums1[i] = nums3[i]


作者：yizhu-jia
链接：https://leetcode-cn.com/problems/merge-sorted-array/solution/wuyu-by-yizhu-jia-e29j/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

89 格雷码

看的答案  真的不会...

        res = [0]
        for i in range(n):
            head = 2 **i
            for j in range(len(res) - 1, -1, -1):
                res.append(head + res[j])
        return res