LeetCode笔记：Biweekly Contest 101

• LeetCode笔记：Biweekly Contest 101
  • 1. 题目一
    • 1. 解题思路
    • 2. 代码实现
  • 2. 题目二
    • 1. 解题思路
    • 2. 代码实现
  • 3. 题目三
    • 1. 解题思路
    • 2. 代码实现
  • 4. 题目四
    • 1. 解题思路
    • 2. 代码实现

• 比赛链接：https://leetcode.com/contest/biweekly-contest-101/

1. 题目一

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

• 2605. Form Smallest Number From Two Digit Arrays

1. 解题思路

这一题中规中矩的，就是一个分类讨论：

• 如果两个array包含相同的元素，那么答案就是这些相同元素当中最小的；
• 如果两个array不包含相同的元素，假设两者的最小元素分别是x和y，则答案必然是xy和yx当中的较小数；

2. 代码实现

给出python代码实现如下：

class Solution:
    def minNumber(self, nums1: List[int], nums2: List[int]) -> int:
        nums1, nums2 = set(nums1), set(nums2)
        if len(nums1 & nums2) > 0:
            return min(nums1 & nums2)
        else:
            return min(min(nums1) + 10 * min(nums2), min(nums2) + 10 * min(nums1))

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

2. 题目二

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

• 2606. Find the Substring With Maximum Cost

1. 解题思路

这一题显然我们可以把每一个字符对应的score给算出来。

然后，我们考察一下累积数组，则任意一个subarray的score都可以用累积数组当中的两数之差来表示。

因此，对以任意位置作为终点的subarray，其能得到的最大值就是当前的值减去之前累积数组的最小值。

遍历以所有的位置最为终点的情况，我们就能获得我们最终的答案。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maximumCostSubstring(self, s: str, chars: str, vals: List[int]) -> int:
        score = {ch: ord(ch)-ord('a')+1 for ch in string.ascii_lowercase}
        for ch, val in zip(chars, vals):
            score[ch] = val
        s = [score[ch] for ch in s]
        s = list(accumulate(s))
        res = 0
        _min = 0
        for x in s:
            if x < _min:
                _min = x
            res = max(res, x-_min)
        return res

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

3. 题目三

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

• 2607. Make K-Subarray Sums Equal

1. 解题思路

这一题比较显然的是，要满足题目给定的条件，对于第i个元素和第i+k个元素必然是相等的。

然后，由于array可以循环，因此，我们对k进行深度处理，假设array长度为n，则k需要变成k与n的最大公约数。

此后，我们就可以将array的元素进行分组，然后对每一个组，我们只需要考察将这个组中的元素全部变为相同的数所需要经过的操作数目即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def makeSubKSumEqual(self, arr: List[int], k: int) -> int:
        s = defaultdict(list)
        n = len(arr)
        k = math.gcd(n, k)
        for i, x in enumerate(arr):
            s[i%k].append(x)
        
        def fn(arr):
            arr = sorted(arr)
            s = sum(arr)
            n = len(arr)
            t = 0
            res = s
            for i, x in enumerate(arr):
                res = min(res, x*i - t + s-t - x*(n-i))
                t += x
            return res
        
        return sum(fn(arr) for arr in s.values())

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

4. 题目四

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

• 2608. Shortest Cycle in a Graph

1. 解题思路

这一题我的思路还是比较暴力的，就是考察每一个点作为起点的情况下回到起点所需的最小的步数。

这样，遍历完所有的点，我们一定可以找到最小的环。

而对于每一个点如何去找寻最小的回到起点的步数，我们只需要使用一个bfs即可，当某一个点的next step出现在历史路径当中时，对应的最小环长度就是两者距离之和。

2. 代码实现

给出python代码实现如下：

class Solution:
    def findShortestCycle(self, n: int, edges: List[List[int]]) -> int:
        graph = defaultdict(list)
        for u, v in edges:
            graph[u].append(v)
            graph[v].append(u)

        seen = set()
        res = n+1
        for u in range(n):
            q = [(u, -1, 0)]
            distances = {}
            loop = False
            while (not loop) and q:
                u, pre, d = q.pop(0)
                seen.add(u)
                distances[u] = d
                for v in graph[u]:
                    if v in distances:
                        if v == pre:
                            continue
                        res = min(res, d+1 + distances[v])
                        loop = True
                    else:
                        q.append((v, u, d+1))

        return res if res <= n else -1

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