LeetCode笔记:Weekly Contest 244 比赛记录

1. 题目一

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

1. 解题思路

第一题暴力解决就能够搞定了,直接将旋转变换进行实现,然后考察一下旋转之后的结果与目标结果是否完全一致即可。

最多经过4次旋转,我们就能够获得最终的解答。

2. 代码实现

给出python代码实现如下:

class Solution:
    def findRotation(self, mat: List[List[int]], target: List[List[int]]) -> bool:
        n = len(mat)
        
        def rotate(mat):
            res = [[0 for _ in range(n)] for _ in range(n)]
            for i in range(n):
                for j in range(n):
                    res[j][n-1-i] = mat[i][j]
            return res
        
        if all(mat[i][j] == target[i][j] for i in range(n) for j in range(n)):
            return True
        for _ in range(3):
            mat = rotate(mat)
            if all(mat[i][j] == target[i][j] for i in range(n) for j in range(n)):
                return True
        return False

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

2. 题目二

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

1. 解题思路

这一题中操作的本质就是将最大的数变为次大的数,因此经过一轮操作之后,所有最大的数都会变为次大的数,经过的操作次数就会是当前最大的数的数目,而下一轮操作时最大的数的数目就会是所有原始数据中比他大的数的总数。

因此,本质上来说,最终的解答就是一个二轮的累计求和的过程,故我们很简单就能够给出最终的解答。

2. 代码实现

给出python代码实现如下:

class Solution:
    def reductionOperations(self, nums: List[int]) -> int:
        cnt = Counter(nums)
        cnt = sorted(cnt.items(), key=lambda x: x[0], reverse=True)
        n = len(cnt)
        res = 0
        pre = 0
        for i in range(n-1):
            res += pre + cnt[i][1]
            pre += cnt[i][1]
        return res

提交代码评测得到:耗时1172ms,占用内存28.5MB。

3. 题目三

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

1. 解题思路

这一题坦率地说我倒是没有很好的思路,参考了别人的解答之后发现事实上别人也是暴力遍历的……

显然,假设没有条件1,那么就是统计一下奇数位和偶数位上面的0、1个数即可,然后就能够快速求解出答案,因为最终要么是奇数位上全为1,偶数位上全为0,要么反之。

但是,比较坑爹的是条件1可能会破坏原始序列当中的0、1的奇偶位数关系。

因此,最终我们的处理办法就是全部挪一边,遍历所有的奇偶位关系然后进行解答。

2. 代码实现

给出python代码实现如下:

class Solution:
    def minFlips(self, s: str) -> int:
        n = len(s)
        cnt = [[0, 0], [0, 0]]
        for i, c in enumerate(s):
            cnt[ord(c)-ord('0')][i%2] += 1
        # print(cnt)
        d1 = abs((n+1)//2 - cnt[0][0]) + abs(n//2 - cnt[1][1])
        d2 = abs((n+1)//2 - cnt[1][0]) + abs(n//2 - cnt[0][1])
        res = min(d1, d2)
        for i in range(n-1):
            cnt[ord(s[i])-ord('0')][0] -= 1
            cnt[ord(s[i])-ord('0')][n % 2] += 1
            cnt = [cnt[0][::-1], cnt[1][::-1]]
            # print(cnt)
            d1 = abs((n+1)//2 - cnt[0][0]) + abs(n//2 - cnt[1][1])
            d2 = abs((n+1)//2 - cnt[1][0]) + abs(n//2 - cnt[0][1])
            res = min(res, d1, d2)
        return res

提交代码评测得到:耗时1460ms,占用内存15MB。

4. 题目四

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

1. 解题思路

这一题坦率地说虽然标记为一道hard的题目,不过感觉事实上思路上比上一题更加清晰。

我们只需要先对box和package进行排序,然后使用二叉搜索的方式分别计算一下每个箱子可以装的包裹的位置,然后就可以计算出waste,且计算waste的过程我们可以通过事先对package进行累计求和的方式简化计算。

这样,我们就能够快速地得到最终的答案了。

更进一步的,由于显然要求最大的package能够被装载,因此我们可以事先根据box的最大值来进行一下过滤,事先排除掉所有无效解,从而可以优化执行效率。

2. 代码实现

我们给出最终的python解答如下:

class Solution:
    def minWastedSpace(self, packages: List[int], boxes: List[List[int]]) -> int:
        MOD = 10**9 + 7
        packages = sorted(packages)
        s = [0] + list(accumulate(packages))
        boxes = [item for item in boxes if max(item) >= packages[-1]]
        
        if boxes == []:
            return -1
        
        def cal_waste(box):
            box = sorted(box)
            last = 0
            waste = 0
            for k in box:
                idx = bisect.bisect_right(packages, k)
                waste += (idx-last) * k - (s[idx] - s[last])
                last = idx
            return waste
        
        return min(cal_waste(box) for box in boxes) % MOD

提交代码评测得到:耗时2276ms,占用内存38.8MB。

  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
KMP算法是一种字符串匹配算法,用于在一个文本串S内查找一个模式串P的出现位置。它的时间复杂度为O(n+m),其中n为文本串的长度,m为模式串的长度。 KMP算法的核心思想是利用已知信息来避免不必要的字符比较。具体来说,它维护一个next数组,其中next[i]表示当第i个字符匹配失败时,下一次匹配应该从模式串的第next[i]个字符开始。 我们可以通过一个简单的例子来理解KMP算法的思想。假设文本串为S="ababababca",模式串为P="abababca",我们想要在S中查找P的出现位置。 首先,我们可以将P的每个前缀和后缀进行比较,得到next数组: | i | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | | --- | - | - | - | - | - | - | - | - | | P | a | b | a | b | a | b | c | a | | next| 0 | 0 | 1 | 2 | 3 | 4 | 0 | 1 | 接下来,我们从S的第一个字符开始匹配P。当S的第七个字符和P的第七个字符匹配失败时,我们可以利用next[6]=4,将P向右移动4个字符,使得P的第五个字符与S的第七个字符对齐。此时,我们可以发现P的前五个字符和S的前五个字符已经匹配成功了。因此,我们可以继续从S的第六个字符开始匹配P。 当S的第十个字符和P的第八个字符匹配失败时,我们可以利用next[7]=1,将P向右移动一个字符,使得P的第一个字符和S的第十个字符对齐。此时,我们可以发现P的前一个字符和S的第十个字符已经匹配成功了。因此,我们可以继续从S的第十一个字符开始匹配P。 最终,我们可以发现P出现在S的第二个位置。 下面是KMP算法的C++代码实现:
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值