【Leetcode第226场周赛】score:18 Time: 2:04:05 Rank:461 / 4033

5654. 盒子中小球的最大数量（3分，通过率：2830/4026）

你在一家生产小球的玩具厂工作，有 n 个小球，编号从 lowLimit 开始，到 highLimit 结束（包括 lowLimit 和 highLimit ，即 n == highLimit - lowLimit + 1）。另有无限数量的盒子，编号从 1 到 infinity 。
你的工作是将每个小球放入盒子中，其中盒子的编号应当等于小球编号上每位数字的和。例如，编号 321 的小球应当放入编号 3 + 2 + 1 = 6 的盒子，而编号 10 的小球应当放入编号 1 + 0 = 1 的盒子。
给你两个整数 lowLimit 和 highLimit ，返回放有最多小球的盒子中的小球数量。如果有多个盒子都满足放有最多小球，只需返回其中任一盒子的小球数量。

class Solution:
    def countBalls(self, lowLimit: int, highLimit: int) -> int:
        box = [0]*10000
        for i in range(lowLimit,highLimit+1):
            num = 0
            while(i):
                num += i%10
                i //= 10
            box[num] += 1
        return max(box)

5665. 从相邻元素对还原数组（4分，通过率：1438/2874）

存在一个由 n 个不同元素组成的整数数组 nums ，但你已经记不清具体内容。好在你还记得 nums 中的每一对相邻元素。
给你一个二维整数数组 adjacentPairs ，大小为 n - 1 ，其中每个 adjacentPairs[i] = [ui, vi] 表示元素 ui 和 vi 在 nums 中相邻。
题目数据保证所有由元素 nums[i] 和 nums[i+1] 组成的相邻元素对都存在于 adjacentPairs 中，存在形式可能是 [nums[i], nums[i+1]] ，也可能是 [nums[i+1], nums[i]] 。这些相邻元素对可以 按任意顺序 出现。
返回 原始数组 nums 。如果存在多种解答，返回 其中任意一个 即可。

class Solution:
    def restoreArray(self, adjacentPairs: List[List[int]]) -> List[int]:
        n = len(adjacentPairs)+1
        ans = []
        dic = collections.defaultdict(lambda:0)
        relation_dic = collections.defaultdict(list)
        for i in adjacentPairs:
            dic[i[0]] += 1
            dic[i[1]] += 1
            relation_dic[i[0]].append(i[1])
            relation_dic[i[1]].append(i[0])
        min_key,min_time = 99999999,99999999999
        for key in dic:
            if dic[key]<min_time:
                min_time,min_key = dic[key],key
        ans.append(min_key)
        for i in range(1,n):
            c = collections.Counter(relation_dic[min_key])
            key_,time = 99999999,999999999
            for key in c:
                if c[key]<time:
                    key_,time = key,c[key]
            ans.append(key)
            relation_dic[key].remove(min_key)
            relation_dic[min_key].remove(key)
            min_key = key
        return ans

5667. 你能在你最喜欢的那天吃到你最喜欢的糖果吗？（5分，通过率：887/4678）

class Solution:
    def canEat(self, candiesCount: List[int], queries: List[List[int]]) -> List[bool]:
        ans = []
        sum_ = 0
        dic = {-1:0}
        for i in range(len(candiesCount)):
            sum_ += candiesCount[i]
            dic[i] = sum_
        
        for qu in queries:
            type_,day_,max_=qu[0],qu[1],qu[2]
            can_eat = dic[type_]-1
            must_eat = dic[type_-1]
            if can_eat<day_:
                ans.append(False)
            else:
                if must_eat>=max_*(day_+1):
                    ans.append(False)
                else:
                    ans.append(True)
        return ans

5666. 回文串分割 IV（6分，通过率：653/2013）

给你一个字符串 s ，如果可以将它分割成三个 非空 回文子字符串，那么返回 true ，否则返回 false 。
当一个字符串正着读和反着读是一模一样的，就称其为 回文字符串 。

class Solution:
    def checkPartitioning(self, s: str) -> bool:
        
        n = len(s)
        if n==3:
            return True
        self.flag = False
        def helper(j,cnt):
            if cnt>3 or (cnt==3 and j!=n) or self.flag or (n-j+cnt)<3:
                return
            if j == n :
                self.flag = True
            if cnt==2:
                if s[j:n] != s[j:n][::-1]:
                    return
            for i in range(j,n):
                if s[j:i+1] != s[j:i+1][::-1]:
                    continue
                if self.flag != True:
                    helper(i+1,cnt+1)
                else:
                    return
        helper(0,0)
        return self.flag