leetcode python刷题记录（九）（81~90）

leetcode python刷题记录（九）（81~90）

81. 搜索旋转排序数组 II

class Solution:
    def search(self, nums: List[int], target: int) -> bool:

        left,right=0,len(nums)-1

        while left<=right:
            mid=(left+right)//2

            if nums[mid]==target:
                return True
            
            if nums[mid]>nums[left]: # 左半部分必然有序：
                if nums[left]<=target<nums[mid]: # 如果target在这个范围内，则舍弃右半部分
                    right=mid-1
                else: # 如果target不在这个范围内，舍弃左半部分
                    left=mid+1

            elif nums[mid]<nums[left]: # 右半部分必然有序
                if nums[mid]<target<=nums[right]:
                    left=mid+1
                else:
                    right=mid-1

            else:
                left=left+1

        return False  

82. 删除排序链表中的重复元素 II

class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy=ListNode(0)
        dummy.next=head

        cur=dummy
        while cur.next and cur.next.next:
            if cur.next.val==cur.next.next.val:
                t=cur.next.val
                while cur.next and cur.next.val==t:
                    cur.next=cur.next.next
            else:
                cur=cur.next

        return dummy.next

83. 删除排序链表中的重复元素

class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:

        if head is None:
            return None
        
        cur=head

        while cur.next:
            if cur.val==cur.next.val:
                cur.next=cur.next.next
            else:
                cur=cur.next

        return head

84. 柱状图中最大的矩形

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        n=len(heights)
        l,r=[0]*(n+1),[0]*(n+1)

        # 我们栈中元素存储的是下标，而对于两端的柱子，它们两侧的边界分别为-1和n。
        # 先从左往右循环，找到每个元素左边第一个比它矮的元素，并放入left数组。再从右往左循环，找到右边第一个比它矮的元素，并放入right数组
        st=[]
        for i in range(n):
            while len(st) and heights[st[-1]]>=heights[i]: # 维护一个单调递增的栈，元素如果比栈顶元素小则弹出栈顶元素，反复执行
                st.pop()
            if not len(st): # 栈为空则直接为左边界
                l[i]=-1
            else: # 不为空则此时栈顶元素即离heights[i]左边最近的小于它的值
                l[i]=st[-1]
            st.append(i)

        st=[]
        for i in range(n-1,-1,-1):
            while len(st) and heights[st[-1]]>=heights[i]:
                st.pop()
            if not len(st):
                r[i]=n
            else:
                r[i]=st[-1]
            st.append(i)

        res=0
        for i in range(n):
            res=max(res,heights[i]*(r[i]-l[i]-1))

        return res

85. 最大矩形

class Solution:
    def maximalRectangle(self, matrix: List[List[str]]) -> int:
        # 思路：先使用前缀和求出每一行每个位置连续1的个数
        # 之后参考84题的方法，用单调栈求出最大矩阵面积
        if not matrix:
            return 0
        
        m,n=len(matrix),len(matrix[0])
        pre=[0]*(n+1)
        res=0

        for i in range(m):
            # 前缀和
            for j in range(n):
                if matrix[i][j]=='1':
                    pre[j]=pre[j]+1
                else:
                    pre[j]=0

            # 单调栈
            stack=[-1]
            for k,num in enumerate(pre):
                while stack and pre[stack[-1]]>num:
                    index=stack.pop()
                    res=max(res,pre[index]*(k-stack[-1]-1))
                stack.append(k)

        return res

86. 分隔链表

class Solution:
    def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
        
        p_head=p=ListNode(0)
        q_head=q=ListNode(0)

        cur=head

        while cur:
            if cur.val<x:
                p.next=cur
                p=p.next

            if cur.val>=x:
                q.next=cur
                q=q.next

            cur=cur.next

        q.next=None
        p.next=q_head.next

        return p_head.next

87. 扰乱字符串

参考：https://leetcode.cn/problems/scramble-string/solution/fu-xue-ming-zhu-ji-yi-hua-di-gui-by-fuxu-r98z/

class Solution:
    @functools.lru_cache(None) 
    # 可以把函数的输入和输出结果缓存住，在后续调用中如果遇到了相同的输入，直接从缓存里面读
    # 递归
    def isScramble(self, s1: str, s2: str) -> bool:
        if len(s1)==0:
            return True
        if len(s1)==1:
            return s1==s2
        if sorted(s1)!=sorted(s2):
            return False
        
        for i in range(1,len(s1)):
            if self.isScramble(s1[:i],s2[:i]) and self.isScramble(s1[i:],s2[i:]):
                return True
            if self.isScramble(s1[:i],s2[-i:]) and self.isScramble(s1[i:],s2[:-i]):
                return True
        
        return False

88. 合并两个有序数组

因为2个输入都是递增排列，所以倒着比大小，把大的放在最后即可

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.
        """
        k=m+n-1

        while m>0 and n>0:
            if nums1[m-1]>nums2[n-1]:
                nums1[k]=nums1[m-1]
                m=m-1
            else:
                nums1[k]=nums2[n-1]
                n=n-1
            k=k-1
        # 当nums2比nums1长的时候，需要把nums2剩下的补到前面。nums1比nums2长的话则无需操作
        nums1[:n]=nums2[:n]

89. 格雷编码

class Solution:
    def grayCode(self, n: int) -> List[int]:
        if n==1:
            return [0,1]
        
        # 为得到第n个格雷编码，则需要将第n-1个编码作反转操作
        left=self.grayCode(n-1)
        right=left.copy() # 镜面对称
        right.reverse() # 反转
        right=[x+(1<<(n-1)) for x in right] #反转后首位补1

        return left+right

90. 子集 II

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:

        # 前面和78题一致，最后加了去重
        def dfs(step):
            if step==len(nums):
                res.append(path[:])
                return
            
            path.append(nums[step])
            dfs(step+1)
            path.pop()
            dfs(step+1)

        res=[]
        path=[]
        nums.sort()
        dfs(0)
        
        # 去重
        r=[]
        for x in res:
            if x not in r:
                r.append(x)

        return r