LeetCode 第132场双周赛个人题解

100324. 清除数字

原题链接

100324. 清除数字

思路分析

一次遍历，相当于用栈进行括号匹配的压入弹出

时间复杂度O(n)

AC代码

class Solution:
    def clearDigits(self, s: str) -> str:
        n = len(s)
        res = []
        cnt = 0
        for x in s:
            if str.isdigit(x):
                res.pop()
            else:
                res.append(x)
        return ''.join(res)

100297. 找到连续赢 K 场比赛的第一位玩家

原题链接

100297. 找到连续赢 K 场比赛的第一位玩家

思路分析

如果最大的人ma到达队头，那么以后的赢家都是ma

换句话讲，在ma到达队头前是否有人能够提前拿到k次胜利？

一次遍历即可

时间复杂度O(n)

AC代码

from sortedcontainers import SortedList
class Solution:
    def findWinningPlayer(self, skills: List[int], k: int) -> int:
        ma = max(skills)
        n = len(skills)
        idx = skills.index(ma)
        cur = tot = 0
        if idx == 0:
            return 0
        for i in range(1, idx + 1):
            if skills[i] < skills[cur]:
                tot += 1
            else:
                cur = i
                tot = 1
            if tot == k:
                return cur
            if i == idx:
                return idx

100331. 求出最长好子序列 I

原题链接

100331. 求出最长好子序列 I

思路分析

考虑O(n^2 k)暴力

定义状态f(i, j)为以nums[i]结尾，nums[x] != nums[x + 1]的x数量为j时的最大长度

那么O(N K)状态数，我们O(N)转移即可

我们每个状态f(i, j)遍历前面的f(x, j)来进行更新

nums[i] = nums[x]，那么更新f(i, j)

如果nums[i] != nums[x]，那么更新f(i, j + 1)

时间复杂度O(n^2 k)

AC代码

from sortedcontainers import SortedList
class Solution:
    def maximumLength(self, nums: List[int], k: int) -> int:
        n = len(nums)
        f = [[0] * (k + 1) for i in range(n)]
        for i in range(n):
            f[i][0] = 1
        res = 1
        for i in range(1, n):
            for j in range(k + 1):
                for x in range(i):
                    if nums[x] == nums[i]:
                        f[i][j] = max(f[i][j], f[x][j] + 1)
                        res = max(res, f[i][j])
                    elif j < k:
                        f[i][j + 1] = max(f[i][j + 1], f[x][j] + 1)
                        res = max(res, f[i][j + 1])
        return res

100327. 求出最长好子序列 II

原题链接

100327. 求出最长好子序列 II

思路分析

昨晚MLE了!!!!佛了，为什么2e6的空间都会被卡啊！！！

这个题的优化很好想，但是不理解为什么要卡空间

我们发现朴素转移就是找前面已经确定的第二维度的最大值来更新我们当前状态

我们直接开个数组记录即可, ma[i] 代表第二维为i的最大长度

但是我们发现我们不知道ma[i]对应的结尾数字，所以我们可以再维护一个数字，但是如果这样写的话有些麻烦，容易把自己绕进去

我们考虑维护两个东西，一个用哈希表same维护nums[i]结尾，第二维为j时的最大长度

一个用一维数组维护第二维为j的最大长度

更新：

用same[nums[i]][j]更新f[i][j]

用ma[j]更新f[i][j + 1]

这样逻辑似乎有漏洞但是不影响正确性

漏洞在于：用ma[j]更新f[i][j + 1]但是ma[j]可能就是以nums[i]结尾，但是我们注意到f[i][j + 1]一定大于等于f[i][j]，因为从逻辑上[j + 1]的限制要小，所以长度可以更长，即使我们用ma[j] + 1更新f[i][j +1 ]也不会使得我们最终答案变得更大或更小

因为如果存在ma[j]对应的结尾数字和nums[i]相同，我们进行更新f[i][j]此时f[i][j - 1]必然会和f[i][j]相同的，如果存在ma[j]对应的结尾数字和nums[i]不同，我们更新出了更大的f[i][j]仍然满足f[i][j] >= f[i][j - 1]

时间复杂度: O(NK)

ps: 用Sortedlist维护卡空间我真的不理解

AC代码

class Solution:
    def maximumLength(self, nums: List[int], k: int) -> int:
        n = len(nums)
        f = [[0] * (k + 1) for _ in range(n)]
        same = defaultdict(list)
        ma = [0] * (k + 1)
        for i in range(n):
            f[i][0] = 1
            same[nums[i]] = [0] * (k + 1)
        for i in range(n):
            for j in range(k + 1):
                f[i][j] = max(f[i][j], same[nums[i]][j] + 1)
                if j < k:
                    f[i][j + 1] = max(f[i][j + 1], ma[j] + 1)
            for j in range(k + 1):
                same[nums[i]][j] = max(same[nums[i]][j], f[i][j])
                ma[j] = max(ma[j], f[i][j])
        
        return max(ma)