LeetCode笔记：Weekly Contest 305

• LeetCode笔记：Weekly Contest 305
  • 0. 小结
  • 1. 题目一
    • 1. 解题思路
    • 2. 代码实现
  • 2. 题目二
    • 1. 解题思路
    • 2. 代码实现
  • 3. 题目三
    • 1. 解题思路
    • 2. 代码实现
  • 4. 题目四
    • 1. 解题思路
    • 2. 代码实现

• 比赛链接：https://leetcode.com/contest/weekly-contest-305/

0. 小结

这次的比赛挺伤的，上午做昨晚的双周赛倒是挺顺利的，没想到下午做这个周赛就滑铁卢了，最后两题都没有自己搞定，可能因为中午没有午睡终究还是影响到了下午的状态吧……

1. 题目一

给出题目一的试题链接如下：

• 2367. Number of Arithmetic Triplets

1. 解题思路

这一题其实就是我们考察每一个元素作为起始元素时能够形成的最长的序列长度。

2. 代码实现

给出python代码实现如下：

class Solution:
    def arithmeticTriplets(self, nums: List[int], diff: int) -> int:
        n = len(nums)
        res = 0
        status = [0 for _ in range(n)]
        for i in range(n):
            if status[i] != 0:
                continue
            pre, cnt = nums[i], 1
            status[i] = 1
            for j in range(i+1, n):
                if nums[j] == pre + diff:
                    cnt += 1
                    pre = nums[j]
                    status[j] = 1
            res += max(0, cnt-2)
        return res

提交代码评测得到：耗时84ms占用内存13.9MB。

2. 题目二

给出题目二的试题链接如下：

• 2368. Reachable Nodes With Restrictions

1. 解题思路

这一题的话我们首先将所有的限制点从树当中删除，然后用一个深度优先遍历即可获得最终的答案。

2. 代码实现

给出python代码实现如下：

class Solution:
    def reachableNodes(self, n: int, edges: List[List[int]], restricted: List[int]) -> int:
        restricted = set(restricted)
        
        if 0 in restricted:
            return 0
        
        graph = defaultdict(list)
        for u, v in edges:
            if u in restricted or v in restricted:
                continue
            graph[u].append(v)
            graph[v].append(u)
        
        res = 0
        def dfs(u, pre):
            nonlocal res
            res += 1
            for v in graph[u]:
                if v == pre:
                    continue
                dfs(v, u)
            return 
        
        dfs(0, -1)
        return res

提交代码评测得到：耗时2704ms，占用内存133.4MB。

3. 题目三

给出题目三的试题链接如下：

• 2369. Check if There is a Valid Partition For The Array

1. 解题思路

这一题一开始我想的复杂了，后来看了一下大佬们的解答之后发现就是一个简单的动态规划，就没啥好多说的了……

2. 代码实现

给出python代码实现如下：

class Solution:
    def validPartition(self, nums: List[int]) -> bool:
        n = len(nums)
        
        @lru_cache(None)
        def dp(idx):
            if idx >= n:
                return True
            if idx + 1 < n and nums[idx] == nums[idx+1] and dp(idx+2):
                return True
            if idx + 2 < n and nums[idx] == nums[idx+1] == nums[idx+2] and dp(idx+3):
                return True
            if idx + 2 < n and nums[idx+1] == nums[idx]+1 and nums[idx+2] == nums[idx]+2 and dp(idx+3):
                return True
            return False
        
        return dp(0)

提交代码评测得到：耗时1744ms，占用内存122.6MB。

4. 题目四

给出题目四的试题链接如下：

• 2370. Longest Ideal Subsequence

1. 解题思路

这一题同样是看了大佬们的解答之后做出来的，本质上都是一个简单的动态规划，不过我自己写的遇到了超时，但是大佬们的解答就能够通过，想不通区别在哪里，原则上要遍历的情况都是$O(26n)$，所以想不通差别在哪。

不过思路上倒是没啥好多说了，大佬们的解答中用cnt来记录结尾在字符i的情况下能够形成的最长子序列长度，剩下的自己看一下代码应该就行了，倒是没啥好多说的……

2. 代码实现

给出python代码实现如下：

class Solution:
    def longestIdealString(self, s: str, k: int) -> int:
        n = len(s)
        s = [ord(ch) - ord('a') for ch in s]
        
        cnt = [0 for _ in range(26)]
        for ch in s:
            cur = 0
            for i in range(26):
                if abs(ch - i) <= k:
                    cur = max(cur, cnt[i])
            cur += 1
            cnt[ch] = max(cnt[ch], cur)
        return max(cnt)

提交代码评测得到：耗时4370ms，真用内存15.9MB。