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,[])
