LeetCode笔记：Weekly Contest 244 比赛记录

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

1. 题目一

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

• 1886. Determine Whether Matrix Can Be Obtained By Rotation

1. 解题思路

第一题暴力解决就能够搞定了，直接将旋转变换进行实现，然后考察一下旋转之后的结果与目标结果是否完全一致即可。

最多经过4次旋转，我们就能够获得最终的解答。

2. 代码实现

给出python代码实现如下：

class Solution:
    def findRotation(self, mat: List[List[int]], target: List[List[int]]) -> bool:
        n = len(mat)
        
        def rotate(mat):
            res = [[0 for _ in range(n)] for _ in range(n)]
            for i in range(n):
                for j in range(n):
                    res[j][n-1-i] = mat[i][j]
            return res
        
        if all(mat[i][j] == target[i][j] for i in range(n) for j in range(n)):
            return True
        for _ in range(3):
            mat = rotate(mat)
            if all(mat[i][j] == target[i][j] for i in range(n) for j in range(n)):
                return True
        return False

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

2. 题目二

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

• 1887. Reduction Operations to Make the Array Elements Equal

1. 解题思路

这一题中操作的本质就是将最大的数变为次大的数，因此经过一轮操作之后，所有最大的数都会变为次大的数，经过的操作次数就会是当前最大的数的数目，而下一轮操作时最大的数的数目就会是所有原始数据中比他大的数的总数。

因此，本质上来说，最终的解答就是一个二轮的累计求和的过程，故我们很简单就能够给出最终的解答。

2. 代码实现

给出python代码实现如下：

class Solution:
    def reductionOperations(self, nums: List[int]) -> int:
        cnt = Counter(nums)
        cnt = sorted(cnt.items(), key=lambda x: x[0], reverse=True)
        n = len(cnt)
        res = 0
        pre = 0
        for i in range(n-1):
            res += pre + cnt[i][1]
            pre += cnt[i][1]
        return res

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

3. 题目三

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

• https://leetcode.com/contest/weekly-contest-244/problems/minimum-number-of-flips-to-make-the-binary-string-alternating/

1. 解题思路

这一题坦率地说我倒是没有很好的思路，参考了别人的解答之后发现事实上别人也是暴力遍历的……

显然，假设没有条件1，那么就是统计一下奇数位和偶数位上面的0、1个数即可，然后就能够快速求解出答案，因为最终要么是奇数位上全为1，偶数位上全为0，要么反之。

但是，比较坑爹的是条件1可能会破坏原始序列当中的0、1的奇偶位数关系。

因此，最终我们的处理办法就是全部挪一边，遍历所有的奇偶位关系然后进行解答。

2. 代码实现

给出python代码实现如下：

class Solution:
    def minFlips(self, s: str) -> int:
        n = len(s)
        cnt = [[0, 0], [0, 0]]
        for i, c in enumerate(s):
            cnt[ord(c)-ord('0')][i%2] += 1
        # print(cnt)
        d1 = abs((n+1)//2 - cnt[0][0]) + abs(n//2 - cnt[1][1])
        d2 = abs((n+1)//2 - cnt[1][0]) + abs(n//2 - cnt[0][1])
        res = min(d1, d2)
        for i in range(n-1):
            cnt[ord(s[i])-ord('0')][0] -= 1
            cnt[ord(s[i])-ord('0')][n % 2] += 1
            cnt = [cnt[0][::-1], cnt[1][::-1]]
            # print(cnt)
            d1 = abs((n+1)//2 - cnt[0][0]) + abs(n//2 - cnt[1][1])
            d2 = abs((n+1)//2 - cnt[1][0]) + abs(n//2 - cnt[0][1])
            res = min(res, d1, d2)
        return res

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

4. 题目四

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

• 1889. Minimum Space Wasted From Packaging

1. 解题思路

这一题坦率地说虽然标记为一道hard的题目，不过感觉事实上思路上比上一题更加清晰。

我们只需要先对box和package进行排序，然后使用二叉搜索的方式分别计算一下每个箱子可以装的包裹的位置，然后就可以计算出waste，且计算waste的过程我们可以通过事先对package进行累计求和的方式简化计算。

这样，我们就能够快速地得到最终的答案了。

更进一步的，由于显然要求最大的package能够被装载，因此我们可以事先根据box的最大值来进行一下过滤，事先排除掉所有无效解，从而可以优化执行效率。

2. 代码实现

我们给出最终的python解答如下：

class Solution:
    def minWastedSpace(self, packages: List[int], boxes: List[List[int]]) -> int:
        MOD = 10**9 + 7
        packages = sorted(packages)
        s = [0] + list(accumulate(packages))
        boxes = [item for item in boxes if max(item) >= packages[-1]]
        
        if boxes == []:
            return -1
        
        def cal_waste(box):
            box = sorted(box)
            last = 0
            waste = 0
            for k in box:
                idx = bisect.bisect_right(packages, k)
                waste += (idx-last) * k - (s[idx] - s[last])
                last = idx
            return waste
        
        return min(cal_waste(box) for box in boxes) % MOD

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