leetcode 第168场周赛

5291. 统计位数为偶数的数字

给你一个整数数组 nums，请你返回其中位数为 偶数 的数字的个数。

范围比较小 只有三种位数，所以暴力统计

class Solution(object):
    def findNumbers(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        ans = 0
        chk = [10,1000,100000]
        for i in nums:
            for j in chk:
                tmp = i//j
                if tmp>=1 and tmp<=9:
                    ans+=1
                    break
        return ans

5292. 划分数组为连续数字的集合

给你一个整数数组 nums 和一个正整数 k，请你判断是否可以把这个数组划分成一些由 k 个连续数字组成的集合。
如果可以，请返回 True；否则，返回 False。

也是暴力统计的题目，可行集合必然可以分割，我们模拟分割的过程，如果不能分割说明集合不可行

class Solution(object):
    def isPossibleDivide(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: bool
        """
        if len(nums)%k != 0:
            return False
        mp = {}
        for i in nums:
            mp[i] = mp.get(i,0)+1
        keys = mp.keys()
        keys.sort()
        for i in keys:
            tmp = mp[i]
            if tmp:
                for j in range(i,i+k):
                    if mp.get(j,0)>=tmp:
                        mp[j]-=tmp
                    else:
                        return False
        for i in keys:
            if mp[i] != 0:
                return False
        return True

5293. 子串的最大出现次数

给你一个字符串 s ，请你返回满足以下条件且出现次数最大的 任意 子串的出现次数：

• 子串中不同字母的数目必须小于等于 maxLetters 。
• 子串的长度必须大于等于 minSize 且小于等于 maxSize 。

题意比较恶心，我的做法就是暴力统计，因为maxSize 只有26

class Solution(object):
    def maxFreq(self, s, maxLetters, minSize, maxSize):
        """
        :type s: str
        :type maxLetters: int
        :type minSize: int
        :type maxSize: int
        :rtype: int
        """
        ans = 0
        mp = {}
        for i in range(0,len(s)-minSize+1):
            cnt = [0]*300
            tmpcnt = 0
            tmpstr = ""
            for j in range(0,minSize-1): # i ~ i+minSize-2
                cnt[ord(s[i+j])]+=1
                if cnt[ord(s[i+j])] == 1:
                    tmpcnt+=1
                tmpstr += s[i+j]
            for j in range(minSize-1,maxSize):# i ~ i+maxSize-1
                if i+j>=len(s):
                    break
                cnt[ord(s[i+j])]+=1
                if cnt[ord(s[i+j])] == 1:
                    tmpcnt+=1
                tmpstr += s[i+j]
                if tmpcnt <= maxLetters:
                    mp[tmpstr] = mp.get(tmpstr,0)+1
                    ans = max(ans,mp[tmpstr])
                else:
                    break
        return ans

5294. 你能从盒子里获得的最大糖果数

给你 n 个盒子，每个盒子的格式为 [status, candies, keys, containedBoxes] ，其中：

• 状态字 status[i]：整数，如果 box[i] 是开的，那么是 1 ，否则是 0 。
• 糖果数 candies[i]: 整数，表示 box[i] 中糖果的数目。
• 钥匙 keys[i]：数组，表示你打开 box[i] 后，可以得到一些盒子的钥匙，每个元素分别为该钥匙对应盒子的下标。
• 内含的盒子 containedBoxes[i]：整数，表示放在 box[i] 里的盒子所对应的下标。
  给你一个 initialBoxes 数组，表示你现在得到的盒子，你可以获得里面的糖果，也可以用盒子里的钥匙打开新的盒子，还可以继续探索从这个盒子里找到的其他盒子。

请你按照上述规则，返回可以获得糖果的 最大数目 。

很显然可以搜索，从初始化的盒子集合开始处理，无法处理的就留着，打开的盒子就拿走糖果，获得新盒子和钥匙，然后再从现有盒子处理重复这个过程
特殊情况下，部分盒子没法打开，如果我们发现某次钥匙且盒子没有更新我们就不再继续处理

class Solution(object):
    def maxCandies(self, status, candies, keys, containedBoxes, initialBoxes):
        """
        :type status: List[int]
        :type candies: List[int]
        :type keys: List[List[int]]
        :type containedBoxes: List[List[int]]
        :type initialBoxes: List[int]
        :rtype: int
        """
        vis = [0]*1010
        def dfs(ownedboxs,ownedkeys):
            tmpans = 0
            if ownedboxs:
                mark = False
                tmpboxs = []
                for j in ownedboxs:
                    if vis[j]:
                        continue
                    if status[j] or j in ownedkeys:
                        vis[j] = 1
                        tmpans += candies[j]
                        ownedkeys.extend(keys[j])
                        tmpboxs.extend(containedBoxes[j])
                        mark = True
                    else:
                        tmpboxs.append(j)
                if mark:
                    return tmpans + dfs(tmpboxs,ownedkeys)
            return tmpans
        return dfs(initialBoxes,[])