python leetcode 81-90

# 81
class Solution:
    def search(self, nums, target):
        l , r = 0 , len(nums) - 1
        while l <= r:
            mid = l + (r - l) // 2
            if nums[mid] == target:
                return True
            if nums[mid] == nums[l] == nums[r]:
                l += 1
                r -= 1
            elif nums[mid] >= nums[l]:
                if nums[l] <= target <nums[mid]:
                    r = mid - 1
                else:
                    l = mid + 1
            else:
                if nums[mid] < target <= nums[r]:
                    l = mid + 1
                else:
                    r = mid - 1
        return False

# 82
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def deleteDuplicates(self, head):
        if head == None or head.next == None:
            return head
        dummy = ListNode(-1)
        dummy.next = head
        i = dummy
        j = dummy.next
        while j:
            while j.next and i.next.val == j.next.val:
                j = j.next
            if i.next == j:
                i = j
            else:
                i.next = j.next
            j = j.next
        return dummy.next

# 83
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if not head: 
            return head
        if head.next and head.val == head.next.val:
            while head.next != None and head.val == head.next.val:
                head = head.next
            return self.deleteDuplicates(head)
        else:
            head.next = self.deleteDuplicates(head.next)
        return head

# 84 单调栈 (好像是这个名字)

class Solution:
    def largestRectangleArea(self, heights):
        stack = []
        heights = [0] + heights + [0]
        res = 0
        for i in range(len(heights)):
            while stack and heights[stack[-1]] > heights[i]:
                tmp = stack.pop()
                res = max(res , (i - stack[-1] - 1) * heights[tmp])
            stack.append(i)
        return res 

# 85 (思想可以参考84)
class Solution:
    def maximalRectangle(self, matrix):
        if not matrix or not matrix[0]:
            return 0
        n = len(matrix[0])
        height = [0] * (n+1)
        max_area = 0
        for row in matrix:
            for i in range(n):
                height[i] = height[i] + 1 if row[i]=='1' else 0
            stack = [-1]
            for j in range(n + 1):
                while height[j] < height[stack[-1]]:
                    h = height[stack.pop()]
                    w = j - 1 - stack[-1]
                    max_area = max(max_area, h * w)                
                stack.append(j)            
        return max_area

# 86
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def partition(self, head: ListNode, x: int) -> ListNode:
        head1, head2 = ListNode(-1), ListNode(-1)
        p1, p2 = head1, head2
        while head:
            if head.val < x:
                p1.next = head
                p1 = p1.next
            else:
                p2.next = head
                p2 = p2.next
            head = head.next
        p1.next = head2.next
        p2.next = None
        return head1.next

# 87 看不懂题啊0 0

# 88
class Solution:
    def merge(self, nums1, m, nums2, n) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        tail, i, j = m + n - 1, m - 1, n - 1
        while i >= 0 and j >= 0:
            if nums1[i] > nums2[j]:
                nums1[tail] = nums1[i]
                i -= 1
            else:
                nums1[tail] = nums2[j]
                j -= 1
            tail -= 1
        for k in range(j, -1, -1):
            nums1[k] = nums2[k]

# 89
class Solution:
    def grayCode(self, n: int) -> List[int]:
        res = [0]
        for i in range(n):
            for j in range(len(res)-1,-1,-1):
                res.append(res[j] + (2**i))
        return res

# 90
class Solution:
    def subsetsWithDup(self, nums):
        res = []
        n=len(nums)
        nums.sort()
        def backtrack(i,tmp):
            res.append(tmp)
            for j in range(i,n):
                if j>i and nums[j]==nums[j-1]:
                    continue    
                backtrack(j+1,tmp+[nums[j]])
        backtrack(0,[])
        return res