5976. 检查是否每一行每一列都包含全部整数

这是我写的：执行用时: 156 ms，内存消耗: 15.5 MB 思路：分别计算每行、每列的任意字母是否都出现了一次，若遍历完了有位置是0说明不满足。

class Solution:
    def checkValid(self, matrix: List[List[int]]) -> bool:
        n = len(matrix)
        arr1 = [[0 for i in range(n)] for j in range(n)]
        arr2 = [[0 for i in range(n)] for j in range(n)]
        for i in range(n):
            for j in range(n):
                num = matrix[i][j] - 1
                arr1[i][num] += 1
                arr2[num][j] += 1
        for i in range(n):
            if 0 in arr1[i]:
                return False
        for i in range(n):
            if 0 in arr2[i]:
                return False
        return True

这是大佬写的：执行用时: 100 ms，内存消耗: 15.4 MB 思路：逐行逐列直接遍历，比我的还快哈哈哈

class Solution:
    def checkValid(self, matrix: List[List[int]]) -> bool:
        n = len(matrix)
        Row, Col =n, n
        a = [x for x in range(1, n + 1)] 
        for row in matrix:
            if sorted(row) != a:
                return False
        for c in range(Col):
            tmp = []
            for r in range(Row):
                tmp.append(matrix[r][c])
            if sorted(tmp) != a:
                return False
        return True

5977. 最少交换次数来组合所有的 1 II

这是大佬写的：执行用时: 196 ms，内存消耗: 18 MB 思路：暴力+动态规划，分别看每个位置是1的开头的时候，需要交换的次数。问题转化为一长串1占据的位置原来有多少0，这里动态规划是为了保留每段字符串0的个数 ，无需全部重算。

class Solution:
    def minSwaps(self, nums: List[int]) -> int:
        N = len(nums)
        count = nums.count(1)
        s_0 = 0
        for i in range(count):
            if nums[i] == 0:
                s_0 += 1
        res = s_0
        left = 1
        right = count % N
        while left < N:
            if nums[left-1] == 0:
                s_0 -= 1
            if nums[right] == 0:
                s_0 += 1
            if s_0 < res:
                res = s_0
            left += 1
            right = (right+1) % N
        return res

5978. 统计追加字母可以获得的单词数

咱写的：直接超时QAQ

class Solution:
    def wordCount(self, startWords: List[str], targetWords: List[str]) -> int:
        res = 0
        startWords.sort(key = lambda x: len(x))
        index = [-1 for i in range(27)]
        preindex = len(startWords[0])
        index[preindex] = 0
        ns = len(startWords)
        for i in range(ns):
            if len(startWords[i]) != preindex:
                index[len(startWords[i])] = i
                preindex = len(startWords[i])
        for tw in targetWords:
            lentw = len(tw)
            if lentw == 1 or index[lentw-1] == -1:
                continue
            for i in range(index[lentw-1], ns):
                if len(startWords[i]) == lentw:
                    break
                flag = True
                for ch in startWords[i]:
                    if ch not in tw:
                        flag = False
                        break
                if flag:
                    res += 1
                    break
        return res

这是大佬写的：执行用时: 512 ms，内存消耗: 28.5 MB 思路：先把startWords里的字符串排序放到集合，然后遍历targetWords中的每个字符串，若去掉中间任意一位后可以在集合中找到，结果+=1。

class Solution:
    def wordCount(self, startWords: List[str], targetWords: List[str]) -> int:
        book, res = set(''.join(sorted(w)) for w in startWords), 0
        for w in targetWords:
            w2 = ''.join(sorted(w))
            res += any((w2[:i] + w2[i+1:]) in book for i in range(len(w2)))
        return res

5979. 全部开花的最早一天

大佬写的：执行用时: 288 ms，内存消耗: 34.9 MB 思路：贪心。我其实都想到了但就是写不出来啊啊啊啊啊啊啊这次周赛真是败得彻头彻尾啊。。。呜呜呜

class Solution:
    def earliestFullBloom(self, plantTime: List[int], growTime: List[int]) -> int:
        a = list(zip(plantTime, growTime))
        a.sort(key=lambda x: -x[1])
        ans, day = 0, 0
        for p in a:
            day += p[0]
            ans = max(ans, day + p[1])
        return ans