Leetcode 周赛 222

T1

直接排序计算

class Solution:
    def maximumUnits(self, boxTypes: List[List[int]], truckSize: int) -> int:
        boxTypes.sort(key = lambda x:x[1])
        ans = 0
        while truckSize and boxTypes:
            ni, nu = boxTypes.pop()
            if truckSize > ni:
                ans += ni * nu
                truckSize -= ni
            else:
                ans += truckSize * nu
                truckSize = 0
        return ans
            

T2

直接计数，因为数据上限是$2^{20}$，所以考虑$2^{21}-ni$是否在hashmap中。需要注意是否重复

class Solution:
    def countPairs(self, deliciousness: List[int]) -> int:
        ans = 0
        cnt = collections.Counter(deliciousness)
        for ni in cnt:
            for i in range(22):
                tar = (1 << i) - ni
                if tar > ni:
                    if tar in cnt:
                        ans += cnt[ni] * cnt[tar]
                elif tar == ni:
                    if cnt[tar] >= 2:
                        ans += cnt[ni] * (cnt[ni] - 1)//2
        return ans % (10**9+7)

T3

考虑中段子数组两个端点，当左端点固定为$l$时，右端点需要满足两个条件：

sum(nums[:l]) <= sum(nums[l:r])
sum(nums[l:r]) <= sum(nums[r:])

用前缀和来做就是

pre[l] <= pre[r] - pre[l] 得pre[r] >= pre[l] *2
pre[r] - pre[l] <= pre[-1] - pre[r] 得 pre[r] <= pre[-1] + pre[l]

由于题目中数组元素非负，所以可以使用二分查找确定r的位置
需要注意中段数组非空

class Solution:
    def waysToSplit(self, nums: List[int]) -> int:
        pre = []
        for ni in nums:
            if not pre:
                pre.append(ni)
            else:
                pre.append(pre[-1] + ni)
        ans = 0
        for i in range(len(nums) - 2):
            sl = pre[i]
            l = bisect.bisect_left(pre, sl*2)
            l = max(l, i + 1) #保证中段数组非空 非常重要不可以注释掉
            rr = bisect.bisect_right(pre, (pre[-1] + sl)/2)
            if rr == len(pre):
                rr -= 1
            ans += (rr - l) if rr > l else 0
            ans %= (10**9+7)
        print(ans)
        return ans %(int(1e9+7))

T4

翻译一下这道题：以target中元素位置为排序标准，求arr中的最长递增子序列与target的差。
那么这就是一道中等题。

class Solution:
    def minOperations(self, target: List[int], arr: List[int]) -> int:
        dic = {
     c:i for i,c in enumerate(target)}
        res = []
        for ni in arr:
            if ni not in dic:
                continue
            p = bisect.bisect_left(res, dic[ni])
            if p == len(res):
                res.append(dic[ni])
            else:
                res[p] = dic[ni]
        
        return len(target) - len(res)