LeetCode笔记：Biweekly Contest 35 比赛记录
- LeetCode笔记：Biweekly Contest 35
- 0. 赛后总结
- 1. 题目一
- 1. 解题思路
- 2. 代码实现
- 2. 题目二
- 1. 解题思路
- 2. 代码实现
- 3. 题目三
- 1. 解题思路
- 2. 代码实现
- 3. 算法优化
- 4. 题目四
- 1. 解题思路
- 2. 代码实现
0. 赛后总结
中文的leetcode果然和我犯冲，这次比赛又是桑心的一逼，题目倒还好，虽然第二第三题卡了一会，但是好歹都做出来了，但是最坑的是第四题居然比赛的时候没做出来，然后比赛结束之后10分钟给搞定了。。。10分钟，就差这10分钟。。。
唉，见鬼了。
整体排名不算差吧，国内前200，世界500多点，但是考虑到双周赛参加的人本来就少，这个成绩就很尴尬了，更何况我就差那么10分钟。。。
算了，不口吐芬芳了，毕竟一晚上过去，也多少看淡了一点，好好梳理一下，然后再接再厉吧。。。
≧ ﹏ ≦
1. 题目一
给出题目一的试题链接如下：
- 5503. 所有奇数长度子数组的和
1. 解题思路
第一题的题目算是中规中矩吧，目标是计算奇数长度的连续子序列的总和的总和。
因此，我们只需要进行一个二重循环遍历就行了。
不过，为了更好地提升代码效率，我们可以求出累积数组，而后序列的求和操作就可以直接换算为一个减法操作就可以了，可以省掉一层循环。
2. 代码实现
给出代码实现如下：
class Solution:
def sumOddLengthSubarrays(self, arr: List[int]) -> int:
cumsum = [0]
for n in arr:
cumsum.append(cumsum[-1] + n)
n = len(arr)
ans = 0
for i in range(n):
for j in range(i+1, n+1,2):
s = cumsum[j] - cumsum[i]
ans += s
return ans
提交代码评测得到：耗时40ms，占用内存14MB。
当前最优解耗时32ms，但是看了一下算法思路本身乃至实现都是几乎完全一样的，因此就不再过多赘述了。
2. 题目二
给出题目二的试题链接如下：
- 5505. 所有排列中的最大和
1. 解题思路
这一题的算法思路本身还是蛮清晰的，其实就是看requests中所有请求之间的重合部分，并按照重合次数对idx进行排序，然后分别从大到小向其中填充入原数组中的元素即可。
但是，比较难的一点在于如何去实现这个算法，要计算重合次数本身并不是一件很轻松的事。
后来倒是想到了一种个人认为比较巧妙的方法，就是对于每一个requests，在首部+1，尾部-1，而后求整个数组的累积和，这样每个idx中的累积和就是这个idx在requests中被重复请求的次数。
从而，我们只需要对idx进行排序，再对数组进行排序，然后对应元素相乘求和即可得到我们最终的答案。
2. 代码实现
给出python代码实现如下：
class Solution:
def maxSumRangeQuery(self, nums: List[int], requests: List[List[int]]) -> int:
MOD = 1000000007
n = len(nums)
counter = [0 for i in range(n+1)]
for st, ed in requests:
counter[st] += 1
counter[ed+1] -= 1
for i in range(1, n+1):
counter[i] += counter[i-1]
counter = sorted(counter[:-1])
nums = sorted(nums)
ans = 0
for i in range(n):
ans = (ans + counter[i] * nums[i]) % MOD
return ans
提交代码评测得到：耗时1664ms，占用内存46.9MB。
当前的最优算法耗时1388ms，但是看了一下其算法本身和我们的算法是完全一致的，唯一不同的就是最后的求和过程他用了一个sum函数。
因此，这里也就不在多做赘述了。
3. 题目三
给出题目三的试题链接如下：
- 5504. 使数组和能被 P 整除
1. 解题思路
第三题我在比赛的时候倒是超时了两次，不过结果发现一次是因为读题失误，一次则是因为数据处理上的问题，思路上倒是一直没啥大的问题，所以后来就直接改对了，算是可喜可贺吧，呵呵。
这一题的解题思路其实也是蛮清晰的，要使得整个数组之和最终能够被p整除，那么我们要做的首先就是求出总的数组之和对p得余数，假设为r，如果r为0，说明本身就能够被整除，那么直接返回0即可；反之，就是去找其中每一个元素k，假设sum[:k+1] % p = r'，那么需要删除的最短序列长度就是下一个使得sum[:k+l] % p = r' + r的数组长度l。
剩下的问题就是代码实现了。
2. 代码实现
我们给出上述思路的一种python实现算法如下：
import math
import collections
class Solution:
def minSubarray(self, nums: List[int], p: int) -> int:
r = 0
counter = collections.defaultdict(list)
counter[0] = [0]
for idx, n in enumerate(nums):
r = (r + n) % p
counter[r].append(idx+1)
if r == 0:
return 0
@lru_cache(None)
def get_min(r1, r2):
s1 = counter.get(r1, [])
s2 = counter.get(r2, [])
n1 = len(s1)
n2 = len(s2)
i = 0
j = 0
ans = math.inf
while i < n1:
while j < n2 and s2[j] < s1[i]:
j += 1
if j == n2:
break
while i < n1 and s1[i] < s2[j]:
i += 1
ans = min(ans, s2[j]-s1[i-1])
return ans
ans = math.inf
for i in counter.keys():
tgt = (i + r) % p
ans = min(ans, get_min(i, tgt))
return ans if ans != len(nums) else -1
提交代码评测得到：耗时916ms，占用内存58.5MB。
当前的最优算法耗时仅576ms，差不多有一倍的差距，说明上述实现肯定有什么改进的地方。
3. 算法优化
看了一下当前最优的解法，发现思路是一致的，但是他们的统计是计算最近一个和为r'-r的元素，这样就可以少做一次遍历，优化了时间复杂度。
给出他们的代码实现如下：
class Solution:
def minSubarray(self, nums: List[int], p: int) -> int:
n = len(nums)
r = sum(nums) % p
if r == 0:
return 0
counter = {
0: 0}
ans = n
s = 0
for idx, k in enumerate(nums):
s = (s + k) % p
tgt = (s - r + p) % p
if tgt in counter:
ans = min(ans, idx+1 - counter[tgt])
counter[s] = idx+1
# print(counter, ans)
# print(counter, ans)
return ans if ans != n else -1
提交代码评测得到：耗时544ms，占用内存32.2MB。为当前最有方案。
4. 题目四
给出题目四的试题链接如下：
- 5506. 奇怪的打印机 II
1. 解题思路
这一题真的可惜了，比赛的时候没能解出来，但实际上这一题并没有很难，思路对了的话花不了太多的时间。
这一题真的可惜了，比赛的时候没能解出来，但实际上这一题并没有很难，思路对了的话花不了太多的时间。
事实上，这一题的思路就是反向画回去，从最顶层的图层开始绘制，一直绘制到不能绘制为止。
首先，我们找到每一种颜色的原始绘制区域，然后，看他是否属于当前的最顶层图层，如果是，那么将其上色，反之就先等等。如果能够一直绘制到底，将所有的颜色都涂上，那么就说明可以实现，反之就说明不能绘制。
2. 代码实现
给出代码实现如下：
class Solution:
def isPrintable(self, grid: List[List[int]]) -> bool:
n = len(grid)
m = len(grid[0])
colors = {
}
for i in range(n):
for j in range(m):
if grid[i][j] not in colors:
colors[grid[i][j]] = [i, j, i, j]
else:
colors[grid[i][j]] = [min(colors[grid[i][j]][0], i), min(colors[grid[i][j]][1], j), max(colors[grid[i][j]][2], i), max(colors[grid[i][j]][3], j)]
colors = colors.items()
painted = [[0 for _ in range(m)] for _ in range(n)]
def is_paintable(block):
c, (x1, y1, x2, y2) = block
for i in range(x1, x2+1):
for j in range(y1, y2+1):
if painted[i][j] == 0 and grid[i][j] != c:
return False
return True
def paint(blocks):
nonlocal painted
c, (x1, y1, x2, y2) = block
for i in range(x1, x2+1):
for j in range(y1, y2+1):
if painted[i][j] == 0:
painted[i][j] = c
return
flag = True
while flag and colors != []:
tmp = []
flag = False
for block in colors:
if is_paintable(block):
paint(colors)
flag = True
else:
tmp.append(block)
colors = tmp
return flag
提交代码评测得到：耗时348ms，占用内存13.9MB。
当前最优算法耗时224ms，差了差不多一半的时间，如果有兴趣的读者可以自行去看一下，这里我就暂时不做什么研究了。。。