力扣（2024.06.25）

1. 76——最小覆盖子串

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

注意：

• 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
• 如果 s 中存在这样的子串，我们保证它是唯一的答案。

标签：哈希表，字符串，滑动窗口（目前不会）

代码：

2. 77——组合

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按任何顺序返回答案。

标签：回溯

代码：

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

3. 78——子集

给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。

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

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

代码：

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

4. 79——单词搜索

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

标签：数组，字符串，回溯，矩阵（目前不会）

代码：

5. 80——删除有序数组中的重复项2

给你一个有序数组 nums ，请你原地删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

标签：数组，双指针

代码：

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        slow = 0
        fast = 0
        while fast < len(nums):
            if slow > 1 and nums[fast] == nums[slow - 2]:
                fast = fast + 1
            else:
                nums[slow] = nums[fast]
                slow = slow + 1
                fast = fast + 1
        return slow