LeetCode笔记：Biweekly Contest 88

Posted 2022-11-18 Espresso Macchiato

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

• 比赛链接：https://leetcode.com/contest/biweekly-contest-88/

1. 题目一

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

• 2423. Remove Letter To Equalize Frequency

1. 解题思路

这一题思路上来说并不复杂，就是对每一个出现的字符的个数进行统计，然后看一下是否可以删除其中某一个字符中的一个元素使得所有出现的字符频次相同。

但是需要注意的是，这里有几个需要注意的地方：

1. 如果仅出现过一个字符，那么删除一个其中一个也不会产生矛盾，所以也是可接受的；
2. 如果某一个字符仅出现过一次，那么删除这个字符之后只要其他字符频次全部相同，也不会出现矛盾；

因此，我们只需要注意一下这几个边界条件即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def equalFrequency(self, word: str) -> bool:
        cnt = list(Counter(word).values())
        
        def is_valid(arr, tgt):
            cnt = 0
            for x in arr:
                if tgt != 1 and (x == tgt+1 or x == 1):
                    cnt += 1
                elif tgt == 1 and x == tgt + 1:
                    cnt += 1
                elif x != tgt:
                    return False
            return (tgt != 1 and cnt == 1) or (tgt == 1 and cnt <= 1)
        
        return len(cnt) == 1 or any(is_valid(cnt, x) for x in cnt)

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

2. 题目二

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

• 2424. Longest Uploaded Prefix

1. 解题思路

这一题我的思路是使用DSU，当有一个视频被加入的时候，就将其与其他加入的视频聚合起来，然后看看视频1是否已经被加入，以及视频1如果被加入了的话，那么视频1所在的集合中最大的视频编号是多少。

而关于DSU的实现，网上已经有了不少博客对其进行介绍，我自己也写过一个（经典算法：并查集（DSU）结构简介），所以这里就不多做展开了。

2. 代码实现

给出python代码实现如下：

class DSU:
    def __init__(self, N):
        self.root = [i for i in range(N)]
        
    def find(self, k):
        if self.root[k] != k:
            self.root[k] = self.find(self.root[k])
        return self.root[k]
    
    def union(self, a, b):
        x = self.find(a)
        y = self.find(b)
        if x != y:
            self.root[x] = y
        return
        

class LUPrefix:

    def __init__(self, n: int):
        self.n = n
        self.status = [0 for _ in range(n)]
        self.dsu = DSU(n)

    def upload(self, video: int) -> None:
        idx = video-1
        self.status[idx] = 1
        if idx - 1 >= 0 and self.status[idx-1] == 1:
            self.dsu.union(idx-1, idx)
        if idx + 1 < self.n and self.status[idx+1] == 1:
            self.dsu.union(idx, idx+1)
        return

    def longest(self) -> int:
        if self.status[0] == 0:
            return 0
        return self.dsu.find(0) + 1

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

3. 题目三

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

• 2425. Bitwise XOR of All Pairings

1. 解题思路

这一题要算所有pair的按位异或之后的值的按位异或的结果，其实就是考察这所有的pair求出来的结果当中每一位上1的个数是奇数还是偶数。

然后，要求解这个问题，我们只需要算出所有pair对求出的按位异或结果中每一位上的1的个数即可，而这个结果我们只需要分别考察num1和num2当中对应位上1和0出现的次数，然后相乘即可。

由此，我们即可对上述问题进行解答。

2. 代码实现

给出python代码实现如下：

class Solution:
    def xorAllNums(self, nums1: List[int], nums2: List[int]) -> int:
        n1, n2 = len(nums1), len(nums2)
        digits1, digits2 = [0 for _ in range(32)], [0 for _ in range(32)]
        for x in nums1:
            x = bin(x)[2:].rjust(32, "0")
            for i in range(32):
                if x[i] == "1":
                    digits1[i] += 1
                    
        for x in nums2:
            x = bin(x)[2:].rjust(32, "0")
            for i in range(32):
                if x[i] == "1":
                    digits2[i] += 1
                    
        
        res = 0
        for i in range(32):
            d1 = digits1[i] * (n2 - digits2[i])
            d2 = (n1-digits1[i]) * digits2[i]
            d = (d1 + d2) % 2
            res = res * 2 + d
        return res

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

4. 题目四

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

• 2426. Number of Pairs Satisfying Inequality

1. 解题思路

这一题其实还挺简单的，只要将原不等式：
$$x_i-x_j\le y_i-y_j+d$$

变换为：
$$x_i-y_i\le x_j-y_j+d$$

因此，我们只需要构造一个新的数组$z_i=x_i-y_i$，然后逐一考察对于每一个$z_i$，其前方有多少元素不大于$z_i+d$即可。

我们只需要维护一个有序数组，然后使用二分查找即可快速得到答案。

2. 代码实现

给出python代码实现如下：

class Solution:
    def numberOfPairs(self, nums1: List[int], nums2: List[int], diff: int) -> int:
        delta = [x-y for x, y in zip(nums1, nums2)]
        elems = []
        res = 0
        for x in delta:
            res += bisect.bisect_right(elems, x + diff)
            bisect.insort(elems, x)
        return res

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