leetcode第162场周赛总结

leetcode第162场周赛总结

第一题：1252. 奇数值单元格的数目

给你一个 n 行 m 列的矩阵，最开始的时候，每个单元格中的值都是 0。
另有一个索引数组 indices，indices[i] = [ri, ci] 中的 ri 和 ci 分别表示指定的行和列（从 0 开始编号）。
你需要将每对 [ri, ci] 指定的行和列上的所有单元格的值加 1。
请你在执行完所有 indices 指定的增量操作后，返回矩阵中 「奇数值单元格」 的数目。

示例1：

输入：n = 2, m = 3, indices = [[0,1],[1,1]]
输出：6
解释：最开始的矩阵是 [[0,0,0],[0,0,0]]。
第一次增量操作后得到 [[1,2,1],[0,1,0]]。
最后的矩阵是 [[1,3,1],[1,3,1]]，里面有 6 个奇数。

示例2：

输入：n = 2, m = 2, indices = [[1,1],[0,0]]
输出：0
解释：最后的矩阵是 [[2,2],[2,2]]，里面没有奇数。

提示：

1 <= n <= 50
1 <= m <= 50
1 <= indices.length <= 100
0 <= indices[i][0] < n
0 <= indices[i][1] < m

分析：
简单题，数据量也不大，暴力可解。
代码如下：

class Solution:
    def oddCells(self, n: int, m: int, indices: List[List[int]]) -> int:
        a = [[0] * m for _ in range(n)]
        for i, j in indices:
            for y in range(m):
                a[i][y] ^= 1
            for x in range(n):
                a[x][j] ^= 1
        ans = 0
        for i in range(n):
            for j in range(m):
                if a[i][j]:
                    ans += 1
        return ans

欣赏一下大神的代码：实际上我们并不需要模拟一遍，我们只要统计每一行和每一列中有多少变化了奇数次。需要注意的是，当一个位置的横坐标变化奇数次并且纵坐标也变化奇数次，那么此时相当于变化了偶数次，所以不用记录。

class Solution:
    def oddCells(self, n: int, m: int, indices: List[List[int]]) -> int:
        row, col = [False] * n, [False] * m
        for r, c in indices:
            row[r] ^= True
            col[c] ^= True
        return sum(ro ^ cl for ro in row for cl in col)

第二题：1253. 重构 2 行二进制矩阵

给你一个 2 行 n 列的二进制数组：
矩阵是一个二进制矩阵，这意味着矩阵中的每个元素不是 0 就是 1。
第 0 行的元素之和为 upper。
第 1 行的元素之和为 lower。
第 i 列（从 0 开始编号）的元素之和为 colsum[i]，colsum 是一个长度为 n 的整数数组。
你需要利用 upper，lower 和 colsum 来重构这个矩阵，并以二维整数数组的形式返回它。
如果有多个不同的答案，那么任意一个都可以通过本题。
如果不存在符合要求的答案，就请返回一个空的二维数组。

示例1：

输入：upper = 2, lower = 1, colsum = [1,1,1]
输出：[[1,1,0],[0,0,1]]
解释：[[1,0,1],[0,1,0]] 和 [[0,1,1],[1,0,0]] 也是正确答案。

示例2：

输入：upper = 2, lower = 3, colsum = [2,2,1,1]
输出：[]

示例3：

输入：upper = 5, lower = 5, colsum = [2,1,2,0,1,0,1,2,0,1]
输出：[[1,1,1,0,1,0,0,1,0,0],[1,0,1,0,0,0,1,1,0,1]]

提示：

1 <= colsum.length <= 10^5
0 <= upper, lower <= colsum.length
0 <= colsum[i] <= 2

分析：
注意是二进制矩阵，即意味着矩阵中的每个元素不是 0 就是 1。那么先考虑colsum里元素为0或2的情况，为0时可以确定在这一列两行的元素都是0，为2时可以确定在这一列两行的元素都是1。我们可以先把这些可以确定的位置给填上。那么剩下的位置对应的情况就是colsun里的元素为1时，有两种情况，要么是第一行的这个元素是1，相应的第二行这个元素为0，要么是第二行的这个元素是1，相应的第一行的这个元素是0。我们可以根据upper和lower来判断是否有可行解（具体细节看代码）。若有可行解，由于题目只要求我们返回一个符合要求的答案即可，所以不妨先使用第一种情况来构建矩阵，即第一行的这个元素是1，相应的第二行这个元素为0，当满足了第一行的和等于upper时，再使用第一种情况来构建矩阵，即第二行的这个元素是1，相应的第一行的这个元素是0。
代码如下：

class Solution:
    def reconstructMatrix(self, upper: int, lower: int, colsum: List[int]) -> List[List[int]]:
        lens = len(colsum)
        a = [None] * lens
        b = [None] * lens
        c = lens
        for i, num in enumerate(colsum):
            if num == 0:
                a[i] = b[i] = 0
                c -= 1
            elif num == 2:
                a[i] = b[i] = 1
                upper -= 1
                lower -= 1
                c -= 1
        if upper >= 0 and lower >= 0 and upper + lower == c:
            for i in range(lens):
                if upper:
                    if a[i] == None:
                        a[i] = 1
                        b[i] = 0
                        upper -= 1
                else:
                    if a[i] == None:
                        a[i] = 0
                        b[i] = 1
            return [a, b]
        else:
            return []

第三题：1254. 统计封闭岛屿的数目

有一个二维矩阵 grid ，每个位置要么是陆地（记号为 0 ）要么是水域（记号为 1 ）。
我们从一块陆地出发，每次可以往上下左右 4 个方向相邻区域走，能走到的所有陆地区域，我们将其称为一座「岛屿」。
如果一座岛屿 完全 由水域包围，即陆地边缘上下左右所有相邻区域都是水域，那么我们将其称为 「封闭岛屿」。
请返回封闭岛屿的数目。

示例1：

输入：grid = [[1,1,1,1,1,1,1,0],[1,0,0,0,0,1,1,0],[1,0,1,0,1,1,1,0],[1,0,0,0,0,1,0,1],[1,1,1,1,1,1,1,0]]
输出：2
解释：
灰色区域的岛屿是封闭岛屿，因为这座岛屿完全被水域包围（即被 1 区域包围）。

示例2：

输入：grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]
输出：1

示例3：

输入：grid = [[1,1,1,1,1,1,1],
[1,0,0,0,0,0,1],
[1,0,1,1,1,0,1],
[1,0,1,0,1,0,1],
[1,0,1,1,1,0,1],
[1,0,0,0,0,0,1],
[1,1,1,1,1,1,1]]
输出：2

提示：

1 <= grid.length, grid[0].length <= 100
0 <= grid[i][j] <=1

分析：
这是一个典型的用dfs求连通域的问题。
代码如下：

class Solution:
    def closedIsland(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        visited = [[0] * n for _ in range(m)]
        
        def dfs(i, j):
            visited[i][j] = 1
            flag = 0
            if i == 0 or i == m-1 or j == 0 or j == n-1:
                flag = 1
            for x, y in [(-1, 0), (0, 1), (1, 0), (0, -1)]:
                if 0 <= i+x < m and 0 <= j+y < n and visited[i+x][j+y] == 0 and grid[i+x][j+y] == 0:
                    if dfs(i+x, j+y) == 0:
                        flag = 1
            if flag:
                return 0
            else:
                return 1
        
        ans = 0
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 0 and visited[i][j] == 0:
                    ans += dfs(i, j)
        return ans

第四题：1255. 得分最高的单词集合

你将会得到一份单词表 words，一个字母表 letters （可能会有重复字母），以及每个字母对应的得分情况表 score。
请你帮忙计算玩家在单词拼写游戏中所能获得的「最高得分」：能够由 letters 里的字母拼写出的 任意 属于 words 单词子集中，分数最高的单词集合的得分。
单词拼写游戏的规则概述如下：
玩家需要用字母表 letters 里的字母来拼写单词表 words 中的单词。
可以只使用字母表 letters 中的部分字母，但是每个字母最多被使用一次。
单词表 words 中每个单词只能计分（使用）一次。
根据字母得分情况表score，字母 ‘a’, ‘b’, ‘c’, … , ‘z’ 对应的得分分别为 score[0], score[1], …, score[25]。
本场游戏的「得分」是指：玩家所拼写出的单词集合里包含的所有字母的得分之和。

示例1：

输入：words = [“dog”,“cat”,“dad”,“good”], letters = [“a”,“a”,“c”,“d”,“d”,“d”,“g”,“o”,“o”], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
输出：23
解释：
字母得分为 a=1, c=9, d=5, g=3, o=2
使用给定的字母表 letters，我们可以拼写单词 “dad” (5+1+5)和 “good” (3+2+2+5)，得分为 23 。
而单词 “dad” 和 “dog” 只能得到 21 分。

示例2：

输入：words = [“xxxz”,“ax”,“bx”,“cx”], letters = [“z”,“a”,“b”,“c”,“x”,“x”,“x”], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
输出：27
解释：
字母得分为 a=4, b=4, c=4, x=5, z=10
使用给定的字母表 letters，我们可以组成单词 “ax” (4+5)， “bx” (4+5) 和 “cx” (4+5) ，总得分为 27 。
单词 “xxxz” 的得分仅为 25 。

示例3：

输入：words = [“leetcode”], letters = [“l”,“e”,“t”,“c”,“o”,“d”], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
输出：0
解释：
字母 “e” 在字母表 letters 中只出现了一次，所以无法组成单词表 words 中的单词。

提示：

1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i] 和 letters[i] 只包含小写的英文字母。

分析：
字典+回溯。使用字典来判断字母表里的还剩下的字母能否组成单词表里的某个单词，若能组成，可以使用回溯的方法决定组成或不组成现在的这个单词，以遍历所有可能的情况，更新所有可能的情况里得分最高的分数即为答案。
代码如下：

import copy
class Solution:
    def maxScoreWords(self, words: List[str], letters: List[str], score: List[int]) -> int:
        dic = collections.Counter(letters)
        self.ans = 0
        lens = len(words)
        def helper(d, s, i):
            self.ans = max(self.ans, s)
            if i < lens:
                helper(copy.deepcopy(d), s, i+1)
                temp = collections.Counter(words[i])
                for key, val in temp.items():
                    if key in d and d[key] >= val:
                        d[key] -= val
                        s += score[ord(key) - ord('a')] * val
                    else:
                        return
                helper(d, s, i+1)
                
        helper(dic, 0, 0)
        return self.ans