LeetCode笔记：Biweekly Contest 46 比赛记录

• LeetCode笔记：Biweekly Contest 46
  • 0. 赛后总结
  • 1. 题目一
    • 1. 解题思路
    • 2. 代码实现
  • 2. 题目二
    • 1. 解题思路
    • 2. 代码实现
  • 3. 题目三
    • 1. 解题思路
    • 2. 代码实现
  • 4. 题目四
    • 1. 解题思路
    • 2. 代码实现

0. 赛后总结

这场比赛打的挺糟心的，之前在和朋友聊天，最后临时决定还是参加了这场比赛，然后从第一题开始就做的很不顺畅……

第一题最后舍弃了时间复杂度，选择了一个暴力方法进行求解，第二题是干脆看错了题目，把一个关键条件弄反了，结果硬生生把一道easy的题目做成了地狱难度，最后3分钟才猛然醒悟，但是已经没有时间做了，最后超时两分钟提交通过，真是要多不甘心有多不甘心。

然后最后一题也是，遇到了超时问题，始终没想到什么好的解决思路……

感觉就是诸事不顺，大概是因为前段时间和朋友聊天吹牛逼立下了flag的关系吧……

1. 题目一

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

• 5668. 最长的美好子字符串

1. 解题思路

这题有一说一，做的不顺的最主要原因事实上还是看错题目的关系，题目的要求包括：

1. 首先必须是美好字符串
2. 给出最长的美好字符串
3. 只有存在多个最长的美好字符串时，给出第一个

我最初的想法是先统计各个字符出现的次数，然后进行统计考察，但是遇到了困难，最后还是直接给出了最暴力的枚举法进行解答的，后续看看有没有更好的解题思路吧……

2. 代码实现

给出暴力求解的代码实现如下：

class Solution:
    def longestNiceSubstring(self, s: str) -> str:
        def is_nice(sub):
            for c in sub:
                if not c.lower() in sub or not c.upper() in sub:
                    return False
            return True
        
        n = len(s)
        res = []
        for i in range(n):
            for j in range(n, i, -1):
                if is_nice(s[i:j]):
                    res.append((s[i:j], i))
        res = sorted(res, key=lambda x: (-len(x[0]), x[1]))
        return "" if res == [] else res[0][0]

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

看了一下当前的代码实现思路，貌似都是暴利求解的……

2. 题目二

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

• 5669. 通过连接另一个数组的子数组得到一个数组

1. 解题思路

这道题其实只要注意匹配顺序必须与给定的groups顺序一致，因此，我们只要采用贪婪匹配的方式进行子数组的注意匹配即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def canChoose(self, groups: List[List[int]], nums: List[int]) -> bool:
        n = len(groups)
        flag = 0
        i = 0
        m = len(nums)
        while i < m and flag < n:
            if nums[i] != groups[flag][0]:
                i += 1
                continue
            status = True
            for j in range(len(groups[flag])):
                if i+j >= m or nums[i+j] != groups[flag][j]:
                    status = False
                    break
            if status:
                i += len(groups[flag])
                flag += 1
            else:
                i += 1
        return flag == n           

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

当前最优的代码实现耗时72ms，但是看了一下，其核心算法思路是相同的，因此就不多做展开了。

3. 题目三

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

• 5671. 地图中的最高点

1. 解题思路

这一题我的解题思路就是bfs，我们首先将最低点加入到队列当中，然后不断更新其邻接点上的高度，然后将邻接点顺序加入到队列当中，直到地图上所有的点全部都被赋予了高度。

2. 代码实现

我们给出python代码实现如下：

class Solution:
    def highestPeak(self, isWater: List[List[int]]) -> List[List[int]]:
        n, m = len(isWater), len(isWater[0])
        q = []
        res = [[-1 for _ in range(m)] for _ in range(n)]
        for i in range(n):
            for j in range(m):
                if isWater[i][j] == 1:
                    res[i][j] = 0
                    q.append((i, j))
        while q:
            i, j = q.pop(0)
            if i-1 >= 0 and res[i-1][j] == -1:
                res[i-1][j] = res[i][j] + 1
                q.append((i-1, j))
            if i+1 < n and res[i+1][j] == -1:
                res[i+1][j] = res[i][j] + 1
                q.append((i+1, j))
            if j-1 >= 0 and res[i][j-1] == -1:
                res[i][j-1] = res[i][j] + 1
                q.append((i, j-1))
            if j+1 < m and res[i][j+1] == -1:
                res[i][j+1] = res[i][j] + 1
                q.append((i, j+1))
        return res

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

当前的最优算法实现耗时4348ms，看了一下他们的算法实现，思路和我们是一致的，都是采用了bfs的思路，因此就不过多展开了，有兴趣的读者可以自行去看一下。

4. 题目四

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

• 5670. 互质树

1. 解题思路

这一题比赛的时候遇到了超时问题，到最后也没有解决。赛后看了一下其他大佬们的解法，发现整体的思路在于使用了深度优先遍历，这个倒是没啥新奇的，不过最核心的优化点在于：

• 他们不是记录每个点的祖先，而是在每一层记录每一个值向上最近的祖先的值。

这样，就不需要记录整个树，而是只要维护1-50这些数向上的最近互质祖先位置即可。

但是他们的解法思路整体上来说确实看的半懂不懂的，就放在下面供读者参考了。

2. 代码实现

给出比赛中那些大佬们的解法如下：

class Solution:
    def getCoprimes(self, nums: List[int], edges: List[List[int]]) -> List[int]:
        n = len(nums)
        graph = [[] for _ in range(n)]
        for u, v in edges:
            graph[u].append(v)
            graph[v].append(u)
            
        primes = [[j for j in range(1, 51) if gcd(i, j) == 1] for i in range(1, 51)]
            
        current = [-1 for _ in range(51)]
        ans = [-1 for _ in range(n)]
        def dfs(x, parent):
            nonlocal current
            ans[x] = current[nums[x]]
            current2 = current[:]
            for j in primes[nums[x] - 1]:
                current[j] = x
            for v in graph[x]:
                if v != parent:
                    dfs(v, x)
            current[:] = current2
        dfs(0, -1)
        return ans

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