LeetCode笔记：Weekly Contest 345-优快云博客

本文链接：https://blog.youkuaiyun.com/codename_cys/article/details/130668206

LeetCode笔记：Weekly Contest 345

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

1. 题目一

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

2682. Find the Losers of the Circular Game

1. 解题思路

这一题按照题目的流程走一遍就行了，倒是没啥额外的问题。

2. 代码实现

给出python代码实现如下：

class Solution:
    def circularGameLosers(self, n: int, k: int) -> List[int]:
        seen = set()
        idx, step = 0, k
        while idx not in seen:
            seen.add(idx)
            idx = (idx + step) % n
            step = (step + k) % n
        return [i+1 for i in range(n) if i not in seen]

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

2. 题目二

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

2683. Neighboring Bitwise XOR

1. 解题思路

这一题其实算是一个脑筋急转弯的题目，想到了基本就是瞬秒……

显然的，编码后的数事实上就是之前连续两个数的异或，因此，如果给出的结果合法，那么显然有数组中所有元素的异或结果为0。

下面，我们只需要给出一组构造，说明当所有元素异或结果为0时必然存在原始数组即可，而这个其实也不难，我们事实上只要给出第一个元素（不妨设为0），事实上就能反解出一组满足体哦阿健的原始数组了……

综上，事实上我们就只需要判断当前给出的数组当中所有元素的异或结果是否为0即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def doesValidArrayExist(self, derived: List[int]) -> bool:
        s = 0
        for x in derived:
            s = s ^ x
        return s == 0

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

3. 题目三

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

2684. Maximum Number of Moves in a Grid

1. 解题思路

这一题其实也挺简单，就是一个动态规划，从最后一列开始反推即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maxMoves(self, grid: List[List[int]]) -> int:
        n, m = len(grid), len(grid[0])
        
        @lru_cache(None)
        def dp(i, j):
            if j == m-1:
                return 0
            res = 0
            if i-1 >= 0 and grid[i-1][j+1] > grid[i][j]:
                res = max(res, 1 + dp(i-1, j+1))
            if grid[i][j+1] > grid[i][j]:
                res = max(res, 1 + dp(i, j+1))
            if i+1 < n and grid[i+1][j+1] > grid[i][j]:
                res = max(res, 1 + dp(i+1, j+1))
            return res
        
        return max(dp(i, 0) for i in range(n))

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

4. 题目四

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

2685. Count the Number of Complete Components

1. 解题思路

这一题我们的思路还算是比较暴力吧，就是用一个dfs，考察一下所有的相互连通的点的组，然后看看每一个组当中所有点的度数是否都恰好为这个组的元素个数减一，如果是，那么这个组就是一个合法组，计数加一即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def countCompleteComponents(self, n: int, edges: List[List[int]]) -> int:
        graph = defaultdict(list)
        for u, v in edges:
            graph[u].append(v)
            graph[v].append(u)
            
        res = 0
        seen = [0 for _ in range(n)]
        for u in range(n):
            if seen[u] == 1:
                continue
            if graph[u] == []:
                res += 1
                seen[u] = 1
                continue

            cnt = defaultdict(int)
            q = [u]
            visited = {u}
            while q:
                u = q.pop(0)
                for v in graph[u]:
                    cnt[v] += 1
                    if v not in visited:
                        q.append(v)
                        visited.add(v)
            if all(x == len(visited)-1 for x in cnt.values()):
                res += 1

            for v in visited:
                seen[v] = 1
        return res