LeetCode笔记：Weekly Contest 316

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

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

1. 题目一

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

• 2446. Determine if Two Events Have Conflict

1. 解题思路

这一题思路很直白，就是看一下就没有时间的重叠即可，因此，我们只需要将时间转换为分钟，就可以直接用数值进行比较了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def haveConflict(self, event1: List[str], event2: List[str]) -> bool:
        
        def fn(t):
            h, m = t.split(":")
            return 60*int(h) + int(m)
        if fn(event1[0]) < fn(event2[0]):
            return fn(event2[0]) <= fn(event1[1])
        else:
            return fn(event1[0]) <= fn(event2[1]) 

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

2. 题目二

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

• 2447. Number of Subarrays With GCD Equal to K

1. 解题思路

这一题我的思路还是非常暴力的，就是一个二重循环。

2. 代码实现

给出python代码实现如下：

class Solution:
    def subarrayGCD(self, nums: List[int], k: int) -> int:
        res = 0
        n = len(nums)
        
        for i in range(n):
            if nums[i] == k:
                res += 1
            s = nums[i]
            for j in range(i+1, n):
                s = gcd(nums[j], s)
                if s % k != 0:
                    break
                if s == k:
                    res += 1
        return res

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

3. 题目三

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

• 2448. Minimum Cost to Make Array Equal

1. 解题思路

这一题思路上来说还是比较暴力地考察以每一个数作为目标值的情况下所需要的调整的cost，然后取出最小值。

于是问题就在于说当以每一个值作为目标值的情况下如何快速地计算出cost。

这个问题的话可以采用累积数组的方式来进行实现，具体来说，我们首先对于nums进行排序，当以nums[i]作为最终的target的情况下，其产生的cost当中来自于增加的那一部分等于之前变换到nums[i-1]为目标时的cost和对于之前所有数的单位cost之和变换nums[i] - nums[i-1]的增值。

同样的，我们也可以通过相同的方式求得cost当中来自于减少的部分带来的cost。两者相加，即是变换为nums[i]时所需的全部cost。

从中，我们取出最小值即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def minCost(self, nums: List[int], cost: List[int]) -> int:
        n = len(nums)
        ids = sorted(range(n), key=lambda x: nums[x])
        nums = [nums[i] for i in ids]
        cost = [cost[i] for i in ids]
        scost = list(accumulate(cost))
        
        increase = [0 for _ in range(n)]
        for i in range(1, n):
            increase[i] = increase[i-1] + scost[i-1] * (nums[i] - nums[i-1])
        
        decrease = [0 for _ in range(n)]
        for i in range(n-2, -1, -1):
            decrease[i] = decrease[i+1] + (scost[-1] - scost[i]) * (nums[i+1] - nums[i])
            
        return min(increase[i] + decrease[i] for i in range(n))

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

4. 题目四

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

• 2449. Minimum Number of Operations to Make Arrays Similar

1. 解题思路

这一题我自己没能搞定，看别人的思路倒是可以理解思路，但是思路的正确性上始终感觉存疑。

这里就简单介绍一下其他大佬们的思路。

大佬们的思路还是比较直接的，首先，由于变换的单位为2，因此奇偶性是不会因为变换而发生改变的，因此，我们只要分别考虑奇偶数序列的结果，然后把两个结果相加即可。

因此，我们只需要考虑只有比如只有偶数的情况下的变换数目即可。

这一个问题，大佬们的思路就非常的暴力，就是对原数组和目标数组进行排序，然后逐一对比考察，只考虑两边的向上加和或者向下加和的距离即可。认为是在题目的可实现性基础上，只要考虑向上加和就一定存在对应的构造实现方式可以实现对应的构造，但是这个问题我还是有点没想清楚。

2. 代码实现

给出python代码实现如下：

class Solution:
    def makeSimilar(self, nums: List[int], target: List[int]) -> int:
        odds1 = sorted([x for x in nums if x % 2 == 1])
        evens1 = sorted([x for x in nums if x % 2 == 0])
        
        odds2 = sorted([x for x in target if x % 2 == 1])
        evens2 = sorted([x for x in target if x % 2 == 0])
        
        def cnt(src, tgt):
            return sum(max(0, x-y) for x, y in zip(src, tgt)) // 2
        
        return cnt(odds1, odds2) + cnt(evens1, evens2)