LeetCode笔记：Biweekly Contest 100

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

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

1. 题目一

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

• 2591. Distribute Money to Maximum Children

1. 解题思路

这一题思路上就是先给每一个孩子分一块钱，然后给尽量多的孩子补到8块钱。

但是，由于不能恰好给4块钱，因此，我们需要对一些特殊的情况进行一下分类讨论，稍微注意下这部分就行了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def distMoney(self, money: int, children: int) -> int:
        money -= children
        if money < 0:
            return -1
        n = money // 7
        r = money % 7 
        if r == 0:
            return n if n <= children else children - 1
        elif r != 3:
            return n if n < children else children - 1
        elif n == children-1:
            return n-1
        else:
            return n if n < children-1 else children - 1

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

2. 题目二

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

• 2592. Maximize Greatness of an Array

1. 解题思路

这一题我们的思路就是一个贪婪算法。

首先我们将所有的数字按顺序排了一下，然后我们的贪婪算法思路就是从小到大每个数都尽量用恰好比它大的数字来匹配他，直到无法匹配为止。

然后统计一下所有成功配对的数字的个数即可。

不过具体实现上，我们用两个counter来优化了一下计算的效率。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maximizeGreatness(self, nums: List[int]) -> int:
        nums = sorted(nums)
        cnt = Counter(nums)
        vals = sorted(cnt.keys())
        remain = Counter(nums)
        n = len(vals)
        res = 0
        for i in range(n-1):
            k = cnt[vals[i]]
            for j in range(i+1, n):
                if k == 0:
                    break
                elif remain[vals[j]] >= k:
                    remain[vals[j]] -= k
                    res += k
                    k = 0
                else:
                    k -= remain[vals[j]]
                    res += remain[vals[j]]
                    remain[vals[j]] = 0
        return res

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

3. 题目三

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

• 2593. Find Score of an Array After Marking All Elements

1. 解题思路

这一题我们的思路就是首先对所有的elements按照取用顺序进行排序，然后另外用一个marked集合来记录当前已经被mark的位置，然后一次取值即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def findScore(self, nums: List[int]) -> int:
        marked = set()
        nums = sorted([(x, i) for i, x in enumerate(nums)])
        res = 0
        for x, i in nums:
            if i in marked:
                continue
            res += x
            marked.add(i)
            marked.add(i+1)
            marked.add(i-1)
        return res

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

4. 题目四

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

• 2594. Minimum Time to Repair Cars

1. 解题思路

这一题其实挺简单的，我们用一个二分法的思路找到最小的可以修复所有车子的时间即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def repairCars(self, ranks: List[int], cars: int) -> int:
        ranks = sorted(ranks)
        
        def can_repair(t):
            cnt = 0
            for r in ranks:
                cnt += int(math.sqrt(t / r))
                if cnt >= cars:
                    return True
            return False
        
        i, j = 0, ranks[-1] * (ceil(cars / len(ranks)))**2
        while j-i > 1:
            t = (i+j) // 2
            if can_repair(t):
                j = t
            else:
                i = t
        return j

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