第 124 场双周赛

第 124 场双周赛

100221. 相同分数的最大操作数目 I - 力扣（LeetCode）

给你一个整数数组 nums ，如果 nums 至少 包含 2 个元素，你可以执行以下操作：

• 选择 nums 中的前两个元素并将它们删除。

一次操作的 分数 是被删除元素的和。

在确保 所有操作分数相同 的前提下，请你求出 最多 能进行多少次操作。

请你返回按照上述要求 最多 可以进行的操作次数。

示例 1：

输入：nums = [3,2,1,4,5]
输出：2
解释：我们执行以下操作：
- 删除前两个元素，分数为 3 + 2 = 5 ，nums = [1,4,5] 。
- 删除前两个元素，分数为 1 + 4 = 5 ，nums = [5] 。
由于只剩下 1 个元素，我们无法继续进行任何操作。

示例 2：

输入：nums = [3,2,6,1,4]
输出：1
解释：我们执行以下操作：
- 删除前两个元素，分数为 3 + 2 = 5 ，nums = [6,1,4] 。
由于下一次操作的分数与前一次不相等，我们无法继续进行任何操作。

提示：

• 2 <= nums.length <= 100
• 1 <= nums[i] <= 1000

思路:

直接正序遍历,每二步一跳,如果出现了不等于target的下标就break

• 时间复杂度$O(n)$
• 空间复杂度$O(1)$

class Solution:
    def maxOperations(self, nums: List[int]) -> int:
        target = nums[0] + nums[1]
        ans = 0
        n = len(nums)
        for i in range(0, n - 1, 2):
            if nums[i] + nums[i + 1] == target:
                ans += 1
            else:
                break
        return ans

3039. 进行操作使字符串为空 - 力扣（LeetCode）

给你一个字符串 s 。

请你进行以下操作直到 s 为 空 ：

• 每次操作 依次 遍历 'a' 到 'z'，如果当前字符出现在 s 中，那么删除出现位置 最早 的该字符。

请你返回进行 最后 一次操作 之前 的字符串 s 。

示例 1：

输入：s = "aabcbbca"
输出："ba"
解释：我们进行以下操作：
- 删除 s = "aabcbbca" 中加粗加斜字符，得到字符串 s = "abbca" 。
- 删除 s = "abbca" 中加粗加斜字符，得到字符串 s = "ba" 。
- 删除 s = "ba" 中加粗加斜字符，得到字符串 s = "" 。
进行最后一次操作之前的字符串为 "ba" 。

示例 2：

输入：s = "abcd"
输出："abcd"
解释：我们进行以下操作：
- 删除 s = "abcd" 中加粗加斜字符，得到字符串 s = "" 。
进行最后一次操作之前的字符串为 "abcd" 。

提示：

• 1 <= s.length <= 5 * 105
• s 只包含小写英文字母。

思路:

我们可以分析得到,最后只有出现次数最多的字符串可以留下,其他的都会被删除,所以我们只需要记录每个字符出现的次数,然后倒序遍历字符串,最后反转字符串就可以得到答案了

• 时间复杂度$O(n)$,仅遍历
• 空间复杂度$O(m)$,set的空间复杂度

class Solution:
    def lastNonEmptyString(self, s: str) -> str:
        cnt = Counter(s)
        mx = max(cnt.values())
        ans = ""
        seen = set()
        for c in s[::-1]:
            if cnt[c] == mx and c not in seen:
                ans += c
                seen.add(c)
        return ans[::-1]

100220. 相同分数的最大操作数目 II - 力扣（LeetCode）

给你一个整数数组 nums ，如果 nums 至少 包含 2 个元素，你可以执行以下操作中的 任意 一个：

• 选择 nums 中最前面两个元素并且删除它们。
• 选择 nums 中最后两个元素并且删除它们。
• 选择 nums 中第一个和最后一个元素并且删除它们。

一次操作的 分数 是被删除元素的和。

在确保 所有操作分数相同 的前提下，请你求出 最多 能进行多少次操作。

请你返回按照上述要求 最多 可以进行的操作次数。

示例 1：

输入：nums = [3,2,1,2,3,4]
输出：3
解释：我们执行以下操作：
- 删除前两个元素，分数为 3 + 2 = 5 ，nums = [1,2,3,4] 。
- 删除第一个元素和最后一个元素，分数为 1 + 4 = 5 ，nums = [2,3] 。
- 删除第一个元素和最后一个元素，分数为 2 + 3 = 5 ，nums = [] 。
由于 nums 为空，我们无法继续进行任何操作。

示例 2：

输入：nums = [3,2,6,1,4]
输出：2
解释：我们执行以下操作：
- 删除前两个元素，分数为 3 + 2 = 5 ，nums = [6,1,4] 。
- 删除最后两个元素，分数为 1 + 4 = 5 ，nums = [6] 。
至多进行 2 次操作。

提示：

• 2 <= nums.length <= 2000
• 1 <= nums[i] <= 1000

思路:

这道题当时做的时候傻了,记忆化搜索一直写错了,一直找不到dfs结束的标志,后来发现不用找到,直接返回0就是结束了,还需要注意这里都是if判断,不是else判断,只有这样才能正确,因为不一定某个先开始的就是最优的

• 时间复杂度:$O(n^2)$
• 空间复杂度:$O(n^2)$

class Solution:
    def maxOperations(self, nums: List[int]) -> int:
        @cache
        def dfs(i: int, j: int, target: int) ->int:
            if i >= j:
                return 0
            res = 0
            if nums[i] + nums[i + 1] == target:
                res = max(res, dfs(i + 2, j, target) + 1)
            if nums[j] + nums[j - 1] == target:
                res = max(res, dfs(i, j - 2, target) + 1)
            if nums[i] + nums[j] == target:
                res = max(res, dfs(i + 1, j - 1, target) + 1)
            return res
        n = len(nums)
        res1 = dfs(2, n - 1, nums[0] + nums[1])  # 最前面两个
        res2 = dfs(0, n - 3, nums[-2] + nums[-1])  # 最后两个
        res3 = dfs(1, n - 2, nums[0] + nums[-1])  # 第一个和最后一个
        return max(res1, res2, res3) + 1  # 加上第一次操作

100205. 修改数组后最大化数组中的连续元素数目 - 力扣（LeetCode）

给你一个下标从 0 开始只包含 正 整数的数组 nums 。

一开始，你可以将数组中 任意数量 元素增加 至多 1 。

修改后，你可以从最终数组中选择 一个或者更多 元素，并确保这些元素升序排序后是 连续 的。比方说，[3, 4, 5] 是连续的，但是 [3, 4, 6] 和 [1, 1, 2, 3] 不是连续的。

请你返回 最多 可以选出的元素数目。

示例 1：

输入：nums = [2,1,5,1,1]
输出：3
解释：我们将下标 0 和 3 处的元素增加 1 ，得到结果数组 nums = [3,1,5,2,1] 。
我们选择元素 [3,1,5,2,1] 并将它们排序得到 [1,2,3] ，是连续元素。
最多可以得到 3 个连续元素。

示例 2：

输入：nums = [1,4,7,10]
输出：1
解释：我们可以选择的最多元素数目是 1 。

提示：

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 106

思路:

这道题完全不会,补的灵神的思路,虽然能看懂,但自己写可能还是想不到,先给个答案把

• 时间复杂度：$O(nlogn)$，其中 n 为 nums 的长度。瓶颈在排序上。
• 空间复杂度：$O(n)$。

class Solution:
    def maxSelectedElements(self, nums: List[int]) -> int:
        nums.sort()
        f = defaultdict(int)
        for x in nums:
            f[x + 1] = f[x] + 1
            f[x] = f[x - 1] + 1
        return max(f.values())