5980. 将字符串拆分为若干长度为 k 的组

这是我写的：
执行用时: 36 ms，内存消耗: 15 MB
思路：直接按长度求余即可。

class Solution:
    def divideString(self, s: str, k: int, fill: str) -> List[str]:
        res = []
        n = len(s)
        num, mod = n // k, n % k
        for i in range(num):
            res.append(s[i*k:(i+1)*k])
        if mod != 0:
            fil = s[num*k:]
            fil += fill * (k - len(fil))
            res.append(fil)
        return res

5194. 得到目标值的最少行动次数

我写的：
执行用时: 28 ms，内存消耗: 15 MB
思路：不能除的时候直接全部减掉即可。

class Solution:
    def minMoves(self, target: int, maxDoubles: int) -> int:
        res = 0
        while target > 1:
            if maxDoubles == 0:
                res += (target-1)
                break
            if target % 2 == 1:
                target -= 1
            else:
                target /= 2
                maxDoubles -= 1
            res += 1
        return int(res)

5982. 解决智力问题

咱写的：
执行用时: 244 ms，内存消耗: 45.5 MB
思路：直接套两层dp会超时，所以用premax记录当前位置能得到的的最高分，每次更新。

class Solution:
    def mostPoints(self, questions: List[List[int]]) -> int:
        n = len(questions)
        dp = [0] * n
        dp[0] = questions[0][0]
        arr = [0] * n
        premax, preindex = 0, 0
        if questions[0][1]+1 < n:
            arr[questions[0][1]+1] = questions[0][0]
            
        for i in range(1, n):
            premax = max(premax, arr[i])
            dp[i] = premax           
            dp[i] += questions[i][0]
            tmp = questions[i][1] + i + 1
            if tmp < n:
                arr[tmp] = max(arr[tmp], dp[i])
        return max(dp)

5983. 同时运行 N 台电脑的最长时间

大佬写的：执行用时: 108 ms，内存消耗: 25.2 MB
思路：超过平均值的，那些电池给一个电脑从头用到尾，所以不考虑这个电脑 也不考虑这个电池。当最大的都不够平均值，那么答案就是剩下的所有电池混用能够维持的最大时间。tqltql555我是废物

class Solution:
    def earliestFullBloom(self, plantTime: List[int], growTime:         		
    	batteries = sorted(batteries, reverse=True)
        sumt = sum(batteries)
        for t in batteries :
            if t > sumt // n :
                n -= 1
                sumt -= t
            else :
                return sumt // n