LeetCode笔记：Biweekly Contest 78-优快云博客

LeetCode笔记：Biweekly Contest 78

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

1. 题目一

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

2269. Find the K-Beauty of a Number

1. 解题思路

这一题思路非常直接，用一个滑动窗口遍历计数一下即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def divisorSubstrings(self, num: int, k: int) -> int:
        s = str(num)
        n = len(s)
        res = 0
        for i in range(n-k+1):
            sub = int(s[i:i+k])
            if sub == 0:
                continue
            if num % sub == 0:
                res += 1
        return res

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

2. 题目二

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

2270. Number of Ways to Split Array

1. 解题思路

这一题事实上只要用一个累积数组即可。

我们首先求出数组的总和，然后考察每一个位置上的前序和是否大于等于总和的一半即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def waysToSplitArray(self, nums: List[int]) -> int:
        s, tot = 0, sum(nums)
        n = len(nums)
        res = 0
        for i in range(n-1):
            s += nums[i]
            if s * 2 >= tot:
                res += 1
        return res

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

3. 题目三

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

2271. Maximum White Tiles Covered by a Carpet

1. 解题思路

这一题其实就是考察一下区间的覆盖，我们只要先将tiles进行一下排序，然后考察以每一个tile的开头作为起点时，能够覆盖住的格数，然后取最大值即可。

而对于每一次能够覆盖的数目计算，我们只要通过一个二叉搜索即可得到最后一个覆盖的位置，然后通过累积数组计算一下两个位置之间的tile的个数即可。

唯一需要注意的就是边界情况，这个还是需要小心一点的。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maximumWhiteTiles(self, tiles: List[List[int]], carpetLen: int) -> int:
        tiles = sorted(tiles)
        n = len(tiles)
        cnt = [0] + [t[1] - t[0] + 1 for t in tiles]
        cnt = list(accumulate(cnt))
        res = 0
        for i in range(n):
            ed = tiles[i][0] + carpetLen
            j = bisect.bisect_left(tiles, [ed, ed])
            if j >= n or tiles[j][0] == ed:
                res = max(res, cnt[j]-cnt[i])
            else:
                res = max(res, cnt[j-1]-cnt[i] + min(tiles[j-1][1]+1, ed) - tiles[j-1][0])
        return res

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

4. 题目四

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

2272. Substring With Largest Variance

1. 解题思路

这一题我的思路还是比较暴力的，就是遍历字符串当中所有出现过的字符，将其组成pair，然后考察一下各个pair下能够组成的最大的variance。

极限情况下，算法复杂度是 $O(26^2 \times n)$ ，勉勉强强可以接受。

那么，剩下的问题就是在一个确定的pair对下面，如何求解最大距离。

这个事实上不难，唯一比较麻烦的就是边界条件需要注意一下，即需要保证两种字符都需要存在。

2. 代码实现

给出python代码实现如下：

class Solution:
    def largestVariance(self, s: str) -> int:
        chars = list(set(s))
        
        res = 0
        for u in chars:
            for v in chars:
                if u == v:
                    continue
                
                cnt = 0
                has_another = False
                _min, last_min = 0, math.inf
                for ch in s:
                    if ch == u:
                        cnt += 1
                        res = max(res, cnt - _min) if has_another else max(res, cnt - last_min)
                    if ch == v:
                        cnt -= 1
                        if cnt >= _min:
                            has_another = True
                            last_min = _min
                        else:
                            last_min = min(last_min, _min)
                            _min = cnt
                            has_another = False
                        res = max(res, cnt - _min) if has_another else max(res, cnt - last_min)
        return res