LeetCode笔记：Biweekly Contest 105

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

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

1. 题目一

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

• 2706. Buy Two Chocolates

1. 解题思路

这一题做一下排序就行了，倒是不需要过多解释。

2. 代码实现

给出python代码实现如下：

class Solution:
    def buyChoco(self, prices: List[int], money: int) -> int:
        prices = sorted(prices)
        remain = money - prices[0] - prices[1]
        return remain if remain >= 0 else money

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

2. 题目二

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

• 2707. Extra Characters in a String

1. 解题思路

这一题我做的还是有些繁琐的，用了一个dfs算法，不断地把每一个字符串的可行匹配方式进行了考察，然后找出一下最终的答案。

2. 代码实现

给出python代码实现如下：

class Solution:
    def minExtraChar(self, s: str, dictionary: List[str]) -> int:
        dictionary = set(dictionary)
        
        n = len(s)
        res = s
        
        @lru_cache(None)
        def dp(idx):
            if idx >= n:
                return 0
            cnt = len(s[idx:])
            for i in range(idx, n):
                if s[idx:i+1] in dictionary:
                    cnt = min(cnt, dp(i+1))
            cnt = min(cnt, 1+dp(idx+1))
            return cnt
        
        return dp(0)

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

3. 题目三

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

• 2708. Maximum Strength of a Group

1. 解题思路

这一题显然就是将正数全部取用，然后负数取从小到大按照取偶数个元素即可。

只是需要注意一下边界条件：

1. 不存在正数的情况
2. 只有一个负数的情况
3. 0存在与否的情况

2. 代码实现

给出python代码实现如下：

class Solution:
    def maxStrength(self, nums: List[int]) -> int:
        pos = [x for x in nums if x > 0]
        neg = [x for x in nums if x < 0]
        have_zero = 0 in nums
        if len(pos) == 0 and len(neg) <= 1:
            return 0 if have_zero else neg[0]
        
        s = 1
        for x in pos:
            s *= x
        neg = sorted(neg)
        for x in neg[:(len(neg) // 2) * 2]:
            s *= x
        return s

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

4. 题目四

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

• 2709. Greatest Common Divisor Traversal

1. 解题思路

这一题做的很上头，因为思路从一开始就是对的，但就是实现上不太好，导致一直超时，做了一个多小时，心态都炸了……

思路上其实很直接，就是用DSU，对每一个数，找出他的质因子，然后进行聚类。

然后看看最终所有的数字是否都能够聚到一个类当中即可。

2. 代码实现

给出python代码实现如下：

class DSU:
    def __init__(self, N):
        self.root = [i for i in range(N)]
        
    def find(self, k):
        if self.root[k] == k:
            return k
        self.root[k] = self.find(self.root[k])
        return self.root[k]
    
    def union(self, a, b):
        x = self.find(a)
        y = self.find(b)
        if x != y:
            self.root[y] = x
        return
    
class PrimeTable:
    def __init__(self):
        self.primes = self.get_primes()

    def get_primes(self):
        n = 10**5
        status = [0 for _ in range(n+1)]
        res = []
        for i in range(2, n):
            if status[i] == 0:
                res.append(i)
                for j in range(i, n, i):
                    status[j] = 1
        return res
    
    @lru_cache(None)
    def get_factors(self, n):
        if n == 1:
            return []
        for p in self.primes:
            if n % p == 0:
                while n % p == 0:
                    n = n // p
                return [p] + self.get_factors(n)

prime_table = PrimeTable()

class Solution:
    def canTraverseAllPairs(self, nums: List[int]) -> bool:
        nums = sorted(nums)
        if any(x == 1 for x in nums):
            return len(nums) == 1
        primes = set()
        for x in nums:
            factors = prime_table.get_factors(x)
            for p in factors:
                primes.add(p)
        # print(primes)
        primes = sorted(primes)
        index = {p: i for i, p in enumerate(primes)}
        m, n = len(primes), len(nums)
        dsu = DSU(n+m)
        for i, x in enumerate(nums):
            for p in prime_table.get_factors(x):
                if x % p == 0:
                    dsu.union(i, n+index[p])
        tgt = dsu.find(0)
        return all(dsu.find(i) == tgt for i in range(n))

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