力扣（2024.07.01）

1. 84——柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

标签：栈，数组，单调栈（目前不会）

代码：

2. 85——最大矩形

给定一个仅包含 0 和 1 、大小为 rows x cols 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。

标签：栈，数组，动态规划，矩阵，单调栈（目前不会）

代码：

3. 86——分隔链表

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在大于或等于 x 的节点之前。

你应当保留两个分区中每个节点的初始相对位置。

标签：链表，双指针

代码：

# 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: Optional[ListNode], x: int) -> Optional[ListNode]:
        pointer1 = dummy1 = ListNode()
        pointer2 = dummy2 = ListNode()
        while head:
            if head.val < x:
                pointer1.next = head
                pointer1 = pointer1.next
            else:
                pointer2.next = head
                pointer2 = pointer2.next
            head = head.next
        pointer2.next = None
        pointer1.next = dummy2.next
        return dummy1.next

4. 87——扰乱字符串

使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：

1. 如果字符串的长度为 1 ，算法停止
2. 如果字符串的长度 > 1 ，执行下述步骤：
   • 在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。
   • 随机决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。
   • 在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。

给你两个长度相等的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。如果是，返回 true ；否则，返回 false 。

标签：字符串，动态规划（目前不会）

代码：

5. 88——合并两个有序数组

给你两个按非递减顺序排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你合并 nums2 到 nums1 中，使合并后的数组同样按非递减顺序排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

标签：数组，双指针，排序

代码：

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.
        """
        pointer1 = m - 1
        pointer2 = n - 1
        pointer3 = m + n - 1
        while pointer1 >= 0 and pointer2 >= 0:
            if nums1[pointer1] > nums2[pointer2]:
                nums1[pointer3] = nums1[pointer1]
                pointer1 = pointer1 - 1
            else:
                nums1[pointer3] = nums2[pointer2]
                pointer2 = pointer2 - 1
            pointer3 = pointer3 - 1
        while pointer2 >= 0:
            nums1[pointer3] = nums2[pointer2]
            pointer2 = pointer2 - 1
            pointer3 = pointer3 - 1

6. 89——格雷编码

n 位格雷码序列是一个由 2n 个整数组成的序列，其中：

• 每个整数都在范围 [0, 2n - 1] 内（含 0 和 2n - 1）
• 第一个整数是 0
• 一个整数在序列中出现不超过一次
• 每对相邻整数的二进制表示恰好一位不同，且
• 第一个和最后一个整数的二进制表示恰好一位不同

给你一个整数 n ，返回任一有效的 n 位格雷码序列。

标签：位运算，数学，回溯（目前不会）

代码：

7. 90——子集2

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。返回的解集中，子集可以按任意顺序排列。

标签：位运算，数组，回溯

代码：

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        def backtrack(nums, res, path, start):
            if path not in res:
                res.append(path.copy())
            for i in range(start, len(nums)):
                path.append(nums[i])
                backtrack(nums, res, path, i + 1)
                path.pop()
        res = []
        path = []
        nums.sort()
        backtrack(nums, res, path, 0)
        return res