LeetCode笔记：Weekly Contest 202 比赛记录

• LeetCode笔记：Weekly Contest 202
  • 0. 赛后总结
  • 1. 题目一
    • 1. 解题思路
    • 2. 代码实现
  • 2. 题目二
    • 1. 解题思路
    • 2. 代码实现
    • 3. 代码优化
  • 3. 题目三
    • 1. 解题思路
    • 2. 代码实现
  • 4. 题目四
    • 1. 解题思路
    • 2. 代码实现

0. 赛后总结

这一次的比赛做的挺糟心的，第四题倒是搞出来了，但是第三题死活整不出来，然后看第一名还只花了7分钟，整个人心态都不好了。。。

诶，烦啊烦！

感觉是不是要休息一阵子，总感觉最近的状态不太好。

1. 题目一

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

• 1550. Three Consecutive Odds

1. 解题思路

这一题没啥花哨的可言，加一个计数器以力破之即可。

2. 代码实现

给出代码实现如下：

class Solution:
    def threeConsecutiveOdds(self, arr: List[int]) -> bool:
        counter = 0
        for n in arr:
            if n % 2 == 1:
                counter += 1
            else:
                counter = 0
            if counter >= 3:
                return True
        return False

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

2. 题目二

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

• 1551. Minimum Operations to Make Array Equal

1. 解题思路

我们考察达到最终结果时的状态，由于原始态的向量为：$[1,3,5,...,2n-1]$，故达到平衡态时，所有的元素变为：$[n,n,n,...,n]$，因此，每一个元素需要的操作次数为：$[n-1,n-3,...n-3,n-1]$。

我们将第$i$个元素与第$n-i$个元素进行配对，两者只需要一套操作便可同时完成。因此，我们用一个for循环便可以求解。

2. 代码实现

给出代码实现如下：

class Solution:
    def minOperations(self, n: int) -> int:
        ans = 0
        for i in range(n-1, 0, -2):
            ans += i
        return ans

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

3. 代码优化

事实上，更简单的，我们可以直接解析求解得到：

$$f(x)=\{\begin{array}{ll}\frac{n^2}{4}& \text{n (mod 2) ≡ 0}\\ \frac{n^2-1}{4}& \text{n (mod 2) ≡ 1}\end{array}$$

翻译为python代码即有：

class Solution:
    def minOperations(self, n: int) -> int:
        return n**2 // 4

提交后评测得到：耗时32ms，占用内存13.9MB。

3. 题目三

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

• 1552. Magnetic Force Between Two Balls

1. 解题思路

这一题我在比赛的时候非常悲催的没能做出来，然后看了一下第一名做这题的耗时，居然只花了2分钟，瞬间整个人都不好了。

我做了一个小时没能做出来，各种超时，而大神们普遍只花了2、3分钟，那只能说明是实现思路上有着根本性的偏差导致做不出来。

我做这题的时候，第一反应就是从position角度进行动态规划 + 剪枝，但是这种情况下需要考虑的总的可能性有$C_n^m$种，很难对其进行有效的剪枝。

或者说至少我没能搞定。

比赛结束之后看了一下头几位大神们的做法，发现，他们的处理思路是反着来的，并不是考虑positions，而是考虑总长度，找到满足条件的最大间隔interval，使得positions在以interval为间隔时可以被分为至少m-1个区间。

如此一来，虽然需要探索的总的区间变长了，但是可以使用二分法将整个复杂度以指数形式减下来。

2. 代码实现

给出上述思路下的代码实现如下：

class Solution:
    def maxDistance(self, position: List[int], m: int) -> int:
        position = sorted(position)
        n = len(position)
        
        def is_possible(interval):
            counter = 1
            last = position[0]
            for p in position[1:]:
                if p - last >= interval:
                    last = p
                    counter += 1
            return counter >= m
    
        st = 1
        ed = position[-1] - position[0] + 1
        while ed - st > 1:
            mid = (st + ed) // 2
            if is_possible(mid):
                st = mid
            else:
                ed = mid
        return st

提交代码之后评测得到：耗时1312ms，占用内存27.4MB。属于当前第一梯队。

4. 题目四

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

• 1553. Minimum Number of Days to Eat N Oranges

1. 解题思路

这一题事实上就是一道简单的动态规划题目。

很显然，当$n<=1$时，所需时间为$n$天。

考察当$n>1$时的情况，要令其最快吃完，我们必然需要令其指数式地下降。因此，最好的解法必定是先将其简直2或3的倍数，而后直接使用策略二或者策略三。

可惜就这题我居然在实做的时候错了好几次，唉，心累。

2. 代码实现

给出代码实现如下：

class Solution:
    def minDays(self, n: int) -> int:
        
        @lru_cache(None)
        def dp(n):
            if n <= 1:
                return n
            return 1 + min(dp(n // 3) + n % 3, dp(n // 2) + n % 2)
        
        return dp(n)

提交后评测得到：耗时36ms，占用内存14.4MB。属于当前第一梯队。