[Leetcode/Python3] 第214场周赛 (Rank 97 / 9769)

最新推荐文章于 2021-12-18 13:34:00 发布

lizju

最新推荐文章于 2021-12-18 13:34:00 发布

阅读量251

点赞数

CC 4.0 BY-SA版权

分类专栏： python3 leetcode周赛

本文链接：https://blog.csdn.net/weixin_42227482/article/details/109595172

python3 同时被 2 个专栏收录

36 篇文章

订阅专栏

leetcode周赛

22 篇文章

订阅专栏

本文提供四个算法题目，包括生成数组的最大值、构建优质字符串、销售颜色球最大利润及创建有序数组的最小代价，涵盖数组操作、字符串处理、贪心算法等核心内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

P1. 获取生成数组中的最大值

给你一个整数 njie jjj 。按下述规则生成一个长度为 n + 1 的数组 nums ：

nums[0] = 0
nums[1] = 1
当 2 <= 2 * i <= n 时，nums[2 * i] = nums[i]
当 2 <= 2 * i + 1 <= n 时，nums[2 * i + 1] = nums[i] + nums[i + 1]
返回生成数组 nums 中的最大值。

class Solution:
    def getMaximumGenerated(self, n: int) -> int:
        if n == 0: return 0
        A = [0] * (n + 1)
        A[0], A[1] = 0, 1
        ret = 1
        for i in range(n+1):
            if i & 1:
                k = i >> 1
                A[i] = A[k] + A[k+1]
            else:    
                k = i >> 1
                A[i] = A[k]
            ret = max(ret, A[i])    
        return ret

P2. 字符频次唯一的最小删除次数

如果字符串 s 中不存在两个不同字符频次相同的情况，就称 s 是优质字符串。

给你一个字符串 s，返回使 s 成为优质字符串需要删除的最小字符数。

字符串中字符的频次是该字符在字符串中的出现次数。例如，在字符串 “aab” 中，‘a’ 的频次是 2，而 ‘b’ 的频次是 1 。

import collections
class Solution:
    def minDeletions(self, s: str) -> int:
        c = collections.Counter(s)
        A = c.values()
        ret = 0
        while len(A) > 1:
            
            A = sorted(A)[::-1]
            if A[0] != A[1]:
                del A[0]
            else:    
                A[1] -= 1
                ret += 1
                if A[1] == 0:
                    del A[1]
                    
        return ret

P3. 销售价值减少的颜色球

你有一些球的库存 inventory ，里面包含着不同颜色的球。一个顾客想要任意颜色总数为 orders 的球。

这位顾客有一种特殊的方式衡量球的价值：每个球的价值是目前剩下的同色球的数目。比方说还剩下 6 个黄球，那么顾客买第一个黄球的时候该黄球的价值为 6 。这笔交易以后，只剩下 5 个黄球了，所以下一个黄球的价值为 5 （也就是球的价值随着顾客购买同色球是递减的）

给你整数数组 inventory ，其中 inventory[i] 表示第 i 种颜色球一开始的数目。同时给你整数 orders ，表示顾客总共想买的球数目。你可以按照任意顺序卖球。

请你返回卖了 orders 个球以后最大总价值之和。由于答案可能会很大，请你返回答案对 109 + 7 取余数的结果。

class Solution:
    def maxProfit(self, inventory: List[int], orders: int) -> int:
        c = collections.Counter(inventory)
        A = []
        mod = 10 ** 9 + 7
        ret = 0
        for k, v in c.items():
            A.append((k, v))
        A = sorted(A)[::-1]    
        print(A)
        def f(a, b, orders):
            p, q = divmod(orders, b)
            delta = b * (a + a - p + 1) * p // 2 + q * (a - p)
            return delta % mod
        while orders:
            if len(A) == 1:
                a, b = A[0]
                return (ret + f(a, b, orders)) % mod
            else:
                a, b = A[0]
                a1, b1 = A[1]
                if (a - a1) * b >= orders:
                    return (ret + f(a, b, orders)) % mod
                else:
                    A[1] = (a1, b1+ b)
                    orders -= (a - a1) * b
                    ret = (ret + f(a, b, (a - a1) * b)) % mod
                    del A[0]
        return ret

P4. 通过指令创建有序数组

给你一个整数数组 instructions ，你需要根据 instructions 中的元素创建一个有序数组。一开始你有一个空的数组 nums ，你需要从左到右遍历 instructions 中的元素，将它们依次插入 nums 数组中。每一次插入操作的代价是以下两者的较小值：

nums 中严格小于 instructions[i] 的数字数目。
nums 中严格大于 instructions[i] 的数字数目。
比方说，如果要将 3 插入到 nums = [1,2,3,5] ，那么插入操作的代价为 min(2, 1) (元素 1 和 2 小于 3 ，元素 5 大于 3 ），插入后 nums 变成 [1,2,3,3,5] 。

请你返回将 instructions 中所有元素依次插入 nums 后的总最小代价。由于答案会很大，请将它对 109 + 7 取余后返回。

import bisect
class Solution:
    def createSortedArray(self, instructions: List[int]) -> int:
        ret = 0
        A = []
        mod = 10 ** 9 + 7
        for x in instructions:
            n = len(A)
            pl = bisect.bisect_left(A, x)
            pr = bisect.bisect_right(A, x)
            ret = (ret + min(pl, n - pr) ) % mod
            bisect.insort(A, x)
        return ret