LeetCode笔记:Biweekly Contest 52 比赛记录

0. 赛后总结

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

1. 题目一

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

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. 题目二

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

1. 解题思路

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

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

  1. s 1 = 1 + . . + n = n ( n + 1 ) 2 s_1 = 1 + .. + n = \frac{n(n+1)}{2} s1=1+..+n=2n(n+1)
  2. s 2 = n + 1 + . . + n + ( 2 × k 1 − 1 ) = k 1 × ( n + k 1 ) s_2 = n+1 + .. + n+(2\times k_1-1) = k_1 \times (n + k_1) s2=n+1+..+n+(2×k11)=k1×(n+k1)
  3. s 3 = n + 2 + . . + n + 2 × k 2 = k 2 × ( n + k 2 + 1 ) s_3 = n+2 + .. + n+2\times k_2 = k_2 \times (n + k_2 + 1) s3=n+2+..+n+2×k2=k2×(n+k2+1)

通过一元二次方程方程的通解,我们很容易就能计算 n n n k 1 k_1 k1 k 2 k_2 k2的值。

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

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. 题目三

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

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. 题目四

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

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。

  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 4
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值