Leetcode 双周赛 39

竞赛地址
反正总是菜鸡受到伤害

拆炸弹

老样子，T1直接模拟

class Solution:
    def decrypt(self, code: List[int], k: int) -> List[int]:
        if not k:
            return [ 0 for _ in range(len(code))]
        ans = [ 0 for _ in range(len(code))]
        for i in range(len(code)):
            if k > 0 :
                for j in range(1,1+k):
                    ans[i] += code[(i+j)%len(code)]
            else:
                for j in range(k,0,1):
                    ans[i] += code[(i+j)%len(code)]
        return ans

使字符串平衡的最少删除次数

总觉得这题在哪里见过…
构造数组cnt,cnt[i]表示在s的第i个字符之前有多少个’b’
那么删除第i个字符前的’b’以及在这之后的’a’就是$len(s)-i-cnt[-1]+2\ast cnt[i]$
所求即为上述最小值

class Solution:
    def minimumDeletions(self, s: str) -> int:
        cnt = [0]
        for ch in s:
            if ch == 'a':
                cnt.append(cnt[-1])
            else:
                cnt.append(cnt[-1] + 1)
        
        ans = len(s) + 1
        for i in range(len(cnt)):
            ans = min(ans, len(s)-i-cnt[-1]+2*cnt[i])
        return ans

到家的最少跳跃次数

bfs，注意的点有要设置跳跃的上界，以及后跳时不能将该点加入fors以避免前跳跳不到该点。

class Solution:
    def minimumJumps(self, forbidden: List[int], a: int, b: int, x: int) -> int:
        if not x :
            return 0
        fors = set(forbidden)
        queue = collections.deque([(0,0,1)])
        while queue:
            cur, lvl, last = queue.popleft()
            if cur == x:
                return lvl
            if 6000>= cur+a  and cur+a not in fors:
                fors.add(cur+a)
                queue.append((cur+a,lvl+1,1))
            if cur-b >0 and  cur-b not in fors and last!=0:
                # fors.add(cur-b)
                queue.append((cur-b,lvl+1,0))
        return -1

分配重复整数

回溯，反正回溯AC了
注意的点：整数的类型不重要，重要的是频数，所以使用Counter得到频数，再整合到频数计数数组（想用字典的，但是会出现迭代过程中字典键变化）
剪枝，直接从quantity[i]开始，否则会超时orz。

class Solution:
    def canDistribute(self, nums: List[int], quantity: List[int]) -> bool:
        numscnt = [0 for _ in range(max(collections.Counter(nums).values())+1)]
        for ni in collections.Counter(nums).values():
            numscnt[ni] += 1
        n = len(quantity)
        def backtrace(i = 0):
            if i == n:
                return True
            for ni in range(quantity[i],len(numscnt)):
                if numscnt[ni]>0:
                    numscnt[ni] -= 1
                    numscnt[ni - quantity[i]] += 1
                    if backtrace(i+1):
                        return True
                    numscnt[ni] += 1
                    numscnt[ni - quantity[i]] -= 1
            return False
        return backtrace()