Leetcode 162场周赛

纪念我的第一次AK，这次题目还是比较简单的，全国也有两百多个人AK，话不多说，下面来看题

第一题 奇数值单元格的数目

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

示例 ：

输入：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 个奇数。

提示

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

解题思路：

直接模拟即可

代码

class Solution {
public:
    int oddCells(int n, int m, vector<vector<int>>& indices) {
        vector<vector<int>> ma(n,vector<int>(m,0));
        int res=0;
        for(int i=0;i<indices.size();i++)
        {
            for(int j=0;j<m;j++) ma[indices[i][0]][j]++;
            for(int j=0;j<n;j++) ma[j][indices[i][1]]++;               
        }
        
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++) if(ma[i][j]%2!=0) res++;
        }
        
        return res;
    }
};

第二题 重构 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

解题思路：

colsum数组元素的值如果为0，那么对应的二进制矩阵的那列一定是两个0，如果元素值是2，那么对应的二进制矩阵的那列一定是两个1，然后再判断colsum数组元素的值是1的情况，先保证第一行满足元素总和达到upper，这样就能确定下来第一行的所有元素，随后第二行也就确定了，然后再判断是否符合lower的要求，满足则直接输出结果，不满足则输出空数组。

代码

class Solution {
public:
    vector<vector<int>> reconstructMatrix(int upper, int lower, vector<int>& colsum) {
        vector<vector<int>> ma(2,vector<int>(colsum.size()));
        int up=0;
        int lw=0;
        bool flag=false;
        for(int i=0;i<colsum.size();i++)
        {
            if(colsum[i]==0) {
                ma[0][i]=0;
                ma[1][i]=0;
            }
            else if(colsum[i]==2) {
                ma[0][i]=1;
                ma[1][i]=1;
                lw++;
                up++;
            }
        }
        
        for(int i=0;i<colsum.size();i++)
        {
            if(colsum[i]==1) {
                if(flag==false){
                    ma[0][i]=1;
                    ma[1][i]=0;
                    up++;
                }
                else{
                    ma[0][i]=0;
                    ma[1][i]=1;
                    lw++;
                }
                if(up==upper) flag=true;
            }
        }
        vector<vector<int>> kong;
       
        if(lw==lower) return ma;
        else return kong;
    }
};

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

有一个二维矩阵 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 {
public:
    int res=0;
    int m=0,n=0;
    bool flag=true;
    void dfs(int i,int j,vector<vector<int>>& grid)
    {
        if(i<0||i>=m||j<0||j>=n) return ;
        if(grid[i][j]==1) return ;
        if(i==0||i==m-1||j==0||j==n-1) flag=false;
        grid[i][j]=1;
        dfs(i+1,j,grid);
        dfs(i-1,j,grid);
        dfs(i,j+1,grid);
        dfs(i,j-1,grid);
    }
    
    void dfs2(int i,int j,vector<vector<int>>& grid)
    {
        if(i<0||i>=m||j<0||j>=n) return ;
        if(grid[i][j]==1) return ;
        grid[i][j]=1;
        dfs(i+1,j,grid);
        dfs(i-1,j,grid);
        dfs(i,j+1,grid);
        dfs(i,j-1,grid);
    }
    
    int closedIsland(vector<vector<int>>& grid) {
        m=grid.size();
        n=grid[0].size();
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(grid[i][j]==0) {
                    if(i==0||i==m-1||j==0||j==n-1) {dfs2(i,j,grid); flag=false;}
                    else dfs(i,j,grid);
                    if(flag==true) {res++; cout << i << " " << j << endl;}
                    flag=true;
                }
            }
        }
        
        return res;
    }
};

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

你将会得到一份单词表 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] 只包含小写的英文字母。

解题思路

直接暴力求解即可

代码

class Solution {
public:
    int maxScoreWords(vector<string>& words, vector<char>& letters, vector<int>& score) {
        int res=0;
        map<char,int> mp;
        for(int i=0;i<letters.size();i++)
        {
            mp[letters[i]]++;
        }
        
        for(int i=1;i< 1<<(words.size()+1);i++)
        {
            map<char,int> mp2=mp;
            int temp=0;
            bool flag=true;
            for(int j=0;j<words.size();j++)
            {
                if((i>>j)&1==1) {
                    for(int k=0;k<words[words.size()-1-j].length();k++)
                    {
                        if(mp2[words[words.size()-1-j][k]]==0) {flag=false;break;}
                        else mp2[words[words.size()-1-j][k]]--;
                        temp+=score[words[words.size()-1-j][k]-'a'];
                    }
                }
                if(flag==false) break;
            }
            if(flag==true) {
                if(temp>res) res=temp;
            }
        }
        
        return res;
    }
};