LeetCode笔记：Weekly Contest 351

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

• 比赛链接：https://leetcode.com/contest/weekly-contest-351/

1. 题目一

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

• 2748. Number of Beautiful Pairs

1. 解题思路

这一题我偷了个懒，直接用了一个暴力的二重循环来处理了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def countBeautifulPairs(self, nums: List[int]) -> int:
        n = len(nums)
        
        res = 0
        for i in range(n-1):
            st = nums[i]
            while st >= 10:
                st = st // 10
            for j in range(i+1, n):
                ed = nums[j] % 10
                if gcd(st, ed) == 1:
                    res += 1
        return res

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

2. 题目二

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

• 2749. Minimum Operations to Make the Integer Zero

1. 解题思路

这一题本质上就是看是否存在某个$k$，使得$n_1-k\times n_2$恰好可以表示为$k$个$2^i$的数之和。

显然，如果可以满足以下几个条件，那么就一定可以做到：

1. $n_1-k\times n_2\ge k$
2. $n_1-k\times n_2$表示为二进制之后其中$1$的个数不大于$k$

因此，我们只需要对其进行一下判断即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def makeTheIntegerZero(self, num1: int, num2: int) -> int:
        
        def count_one(num):
            s = bin(num)[2:]
            return Counter(s)["1"]
        
        for i in range(60):
            num1 -= num2
            if num1 < i+1:
                return -1
            if count_one(num1) <= i+1:
                return i+1
        return -1

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

3. 题目三

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

• 2750. Ways to Split Array Into Good Subarrays

1. 解题思路

这一题就是一个简单的切分问题，找到所有1的位置，然后再任意两个相邻的1之间，假设有$x$个1，那么就对应$x+1$种分割方法，将所有的分割方法数目相乘即可得到最终的答案。

2. 代码实现

给出python代码实现如下：

class Solution:
    def numberOfGoodSubarraySplits(self, nums: List[int]) -> int:
        MOD = 10**9+7
        
        if 1 not in nums:
            return 0
        res = 1
        ones = [i for i, x in enumerate(nums) if x == 1]
        n = len(ones)
        for i in range(n-1):
            res = res * (ones[i+1] - ones[i]) % MOD
        return res

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

4. 题目四

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

• 2751. Robot Collisions

1. 解题思路

这一题就是一个单调序列的问题，我们首先将机器人按照初始位置排序。

然后我们用一个栈来记录所有右行的机器人，对于每一个机器人，如果是右行的，那么直接加入到栈当中即可，对于一个左行的机器人，一定会依次和栈当中的机器人相撞，然后我们对其进行状态更新，直到其自己被撞毁或者所有右行的机器人都被撞毁即可。

最终，我们就可以得到所有机器人的最终状态了，我们返回所有没有被撞毁的机器人即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def survivedRobotsHealths(self, positions: List[int], healths: List[int], directions: str) -> List[int]:
        res = [0 for _ in positions]
        
        robots = [(i, p, h, d) for i, (p,h,d) in enumerate(zip(positions, healths, directions))]
        robots = sorted(robots, key=lambda x: x[1])
        
        s = []
        for idx, position, health, direction in robots:
            if direction == "R":
                s.append([idx, health])
            else:
                while s != [] and s[-1][1] < health:
                    s.pop()
                    health -= 1
                if s == []:
                    res[idx] = health
                elif s[-1][1] == health:
                    s.pop()
                else:
                    s[-1][1] -= 1
        for idx, health in s:
            res[idx] = health
        return [health for health in res if health != 0]

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