LeetCode笔记：Weekly Contest 281

Posted 2022-02-25 Espresso Macchiato

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

1. 题目一

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

• 2180. Count Integers With Even Digit Sum

1. 解题思路

这一题我的解法同样异常暴力，就是遍历一下范围内所有的数字然后一一检验。

2. 代码实现

给出python代码实现如下：

class Solution:
    def countEven(self, num: int) -> int:
        res = 0
        for i in range(1, num+1):
            d = 0
            while i != 0:
                d += i % 10
                i = i // 10
            if d % 2 == 0:
                res += 1
        return res

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

2. 题目二

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

• 2181. Merge Nodes in Between Zeros

1. 解题思路

这一题可以拆分为两个步骤，首先用一个数组保存下来合并后的元素，然后再将其恢复成一个链表就行了。

而这两个子步骤事实上都比较简单，因此这里就不多做展开了……

2. 代码实现

给出python代码实现如下：

class Solution:
    def mergeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]:
        s = 0
        res = []
        while head:
            if head.val == 0:
                node = ListNode(s)
                if res != []:
                    res[-1].next = node
                res.append(node)
                s = 0
            else:
                s += head.val
            head = head.next
        
        return res[1]

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

3. 题目三

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

• 2182. Construct String With Repeat Limit

1. 解题思路

这一题思路其实很简单，就是先用一个counter统计一下所有字母出现的个数，然后按照倒序以及不重复规则重新进行排序就行了。

唯一需要注意的就是各个边界条件，容易出现错误。

2. 代码实现

给出python代码实现如下：

class Solution:
    def repeatLimitedString(self, s: str, repeatLimit: int) -> str:
        cnt = Counter(s)
        res = ""
        letters = string.ascii_lowercase[::-1]
        for i, ch in enumerate(letters):
            if cnt[ch] == 0:
                continue
            j = i+1
            while j < 26 and cnt[ch] >= repeatLimit:
                while j < 26 and cnt[letters[j]] == 0:
                    j += 1
                if j >= 26:
                    break
                r = min(cnt[ch] // repeatLimit, cnt[letters[j]])
                res += (ch * repeatLimit + letters[j]) * r
                cnt[ch] -= repeatLimit * r
                cnt[letters[j]] -= r
            if j >= 26:
                res += ch * min(repeatLimit, cnt[ch])
            elif 0 < cnt[ch] < repeatLimit:
                res += ch * cnt[ch]
            elif cnt[ch] == 0:
                res = res[:-1]
                cnt[letters[j]] += 1
            cnt[ch] = 0
        return res

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

4. 题目四

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

• 2183. Count Array Pairs Divisible by K

1. 解题思路

这一题我们的思路同样相对比较暴力，就是找到每一个数和k的最大公约数，然后对其频数进行统计。

最后，我们用一个二重循环遍历一下各个出现过的约数，看一下有哪些组合能够使得乘积能够整除k。

2. 代码实现

给出python代码实现如下：

class Solution:
    def countPairs(self, nums: List[int], k: int) -> int:
        cds = [gcd(x, k) for x in nums]
        cnt = Counter(cds)
        cds = list(cnt.keys())
        n = len(cds)
        res = 0
        for i in range(n):
            d = cds[i]
            if d * d % k == 0:
                res += cnt[d] * (cnt[d]-1) // 2
            for j in range(i+1, n):
                d2 = cds[j]
                if d * d2 % k == 0:
                    res += cnt[d] * cnt[d2]
        return res

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