LeetCode笔记：Biweekly Contest 52 比赛记录

• LeetCode笔记：Biweekly Contest 52
  • 0. 赛后总结
  • 1. 题目一
    • 1. 解题思路
    • 2. 代码实现
  • 2. 题目二
    • 1. 解题思路
    • 2. 代码实现
  • 3. 题目三
    • 1. 解题思路
    • 2. 代码实现
  • 4. 题目四
    • 1. 解题思路
    • 2. 代码实现

0. 赛后总结

这周是一周双赛，不过因为各种各样的原因两场比赛都是没有参加，赛后花了点时间做了一下，倒是总算还是都做出来了，不过没看时间就是了……

1. 题目一

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

• 1859. Sorting the Sentence

1. 解题思路

这一题没啥好说的，取每个单词的最后一位进行重排序然后合并排序后的单词即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def sortSentence(self, s: str) -> str:
        tokens = sorted([(t[:-1], t[-1]) for t in s.split()], key=lambda x: int(x[1]))
        return " ".join([t[0] for t in tokens])

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

2. 题目二

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

• 1860. Incremental Memory Leak

1. 解题思路

这道题主要还是数学上的一个处理，核心就是考察每一次内存泄漏时的分配。

首先，我们考虑两个memory之间的差值，这部分将会有开始的部分进行填满，然后就会交互分配给两个memory，因此几部分的内存泄漏计算都可以直接写出来：

1. $s_1=1+..+n=\frac{n(n+1)}{2}$
2. $s_2=n+1+..+n+(2\times k_1-1)=k_1\times (n+k_1)$
3. $s_3=n+2+..+n+2\times k_2=k_2\times (n+k_2+1)$

通过一元二次方程方程的通解，我们很容易就能计算$n$，$k_1$和$k_2$的值。

进而，我们就可以快速得到答案了。

2. 代码实现

给出python代码如下：

class Solution:
    def memLeak(self, memory1: int, memory2: int) -> List[int]:
        delta = abs(memory1 - memory2)
        n = int((math.sqrt(8*delta + 1) - 1) / 2)
        if memory1 >= memory2:
            memory1 -= n*(n+1) // 2
        else:
            memory2 -= n*(n+1) // 2

        if memory1 >= memory2:
            k1 = int((math.sqrt(4*memory1+n**2)-n)/2)
            memory1 -= k1**2+n*k1
            k2 = int((math.sqrt(4*memory2+(n+1)**2)-n-1)/2)
            memory2 -= k2**2 + (n+1)*k2
        else:
            k1 = int((math.sqrt(4*memory1+(n+1)**2)-n-1)/2)
            memory1 -= k1**2+(n+1)*k1
            k2 = int((math.sqrt(4*memory2+n**2)-n)/2)
            memory2 -= k2**2 + n*k2
        return [n+k1+k2+1, memory1, memory2]      

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

3. 题目三

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

• 1861. Rotating the Box

1. 解题思路

这一题其实还好，就是烦一点，我们就是需要考察坠落情况，因此就要考察在每一个障碍点上方（即原图左侧）的石子数目，然后在障碍点上方进行堆叠即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def rotateTheBox(self, box: List[List[str]]) -> List[List[str]]:
        n, m = len(box), len(box[0])
        counter = [[] for _ in range(n)]
        res = [["." for _ in range(n)] for _ in range(m)]
        for i in range(n):
            cnt = 0
            for j in range(m):
                if box[i][j] == "#":
                    cnt += 1
                elif box[i][j] == "*":
                    res[j][n-1-i] = "*"
                    counter[i].append((cnt, j))
                    cnt = 0
            counter[i].append((cnt, m))
        
        for i in range(n):
            for cnt, j in counter[i]:
                for k in range(j-cnt, j):
                    res[k][n-1-i] = "#"
        return res

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

4. 题目四

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

• 1862. Sum of Floored Pairs

1. 解题思路

这一题倒是没有想到特别好的思路，想到的就是首先记录下所有的元素的出现次数，然后我们就是对每一个元素不断地向上查找，找到各个整数倍范围内的数字个数，然后进行求和计算。

这个算法的算法复杂度总算不会像暴力求解那么高，不过其实感觉也没好到哪去，索性倒是能通过评测，然后看了一下官方的解题思路，发现也就是这个思路……

2. 代码实现

给出python代码实现如下：

class Solution:
    def sumOfFlooredPairs(self, nums: List[int]) -> int:
        MOD = 10**9 + 7
        n = len(nums)
        cnt = [0 for _ in range(10**5+1)]
        for i in nums:
            cnt[i] += 1
        cumsum = list(accumulate(cnt))
        res = cnt[1] * sum(nums) % MOD
        for i in range(2, 10**5+1):
            if cnt[i] == 0:
                continue
            for j in range(i, 10**5+1, i):
                res = (res + j//i * (cumsum[min(j+i-1, 100000)] - cumsum[j-1]) * cnt[i]) % MOD
        return res % MOD

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