Leetcode数据结构入门第五天（数组）

君叶寒

已于 2022-02-02 21:46:25 修改

阅读量501

点赞数

分类专栏： Leetcode之数据结构入门文章标签： leetcode 数据结构散列表

于 2022-02-02 21:38:49 首次发布

本文链接：https://blog.csdn.net/m0_55937906/article/details/122771314

版权

Leetcode之数据结构入门专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Leetcode数据结构入门第五天（数组）

36. 有效的数独
73. 矩阵置零

36. 有效的数独

题目描述

请你判断一个 9 x 9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

注意：

一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。
空白格用 ‘.’ 表示。

样例一

在这里插入图片描述

输入：board = 
[["5","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
输出：true

样例2：
输入：board = 
[["8","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
输出：false
解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。

思路一

纯暴力破解，就全部遍历咯，对于每一个值，都判断是否满足数独的三个条件，如果不满足就返回false,我这里把判断的三个条件写在函数check中
值得注意的是33小矩阵中的判定：先确定当前值所在小矩阵的第一个元素的横纵坐标：(i/33,j/3*3),遍历这个小矩阵进行比较即可。

参考代码

class Solution {
public:
    bool isValidSudoku(vector<vector<char>>& board) {
        int n=board.size();
        int m=board[0].size();
        //暴力：不知道过得了吗？
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                //填充了数字的进行验证
                if(board[i][j]>='0'&&board[i][j]<='9')
                {
                    if(!check(board,i,j)) return false;
                }
            }
        }
        return true;
    }
    bool check(vector<vector<char>>& board,int i,int j)
    {
        int n=board.size();
        int m=board[0].size();
        //验证当前值在这一行中是否有重复值
        for(int k=0;k<n;k++)
        {
            if(board[i][j]==board[i][k]&&k!=j) return false;
        }
        //验证当前值在这一列中是否有重复值
        for(int k=0;k<m;k++)
        {
            if(board[i][j]==board[k][j]&&k!=i) return false;
        }
        //验证当前值在当前3*3小矩阵中是否有重复值
        int r=(i/3)*3;
        int c=(j/3)*3;//求出小矩阵的横纵坐标位置
        for(int k1=r;k1<r+3;k1++)
        {
            for(int k2=c;k2<c+3;k2++)
            {
                if(board[i][j]==board[k1][k2]&&k1!=i&&k2!=j)
                {
                    return false;
                }
            }
        }
        return true;
        
    }
};

思路二

可以用哈希表来存储每一行，每一列，以及每个小宫格出现的每个值的次数，判断这些存储值是否大于1，如果有大于1的就返回失败。
这里需要存储的有三个维度，分别是所在行，所在列，还有所在的小九宫格（box）,都可以用数组来存储。
实现过程：先定义几个数组，用来存储，然后通过遍历board的每一个元素，在遍历的同时更新存储值，更新完判断每个更新值是否满足要求（即有没有出现一个数字出现2次及以上），不满足要求就返回false。
根据遍历的当前字符，减去字符‘1’就可以获得下标index，用于更新当前行和当前列中的数值，每次加一。
更新box数组，定位到当前小宫格在哪？因为每三行有一个小宫格，每三列也有一个小宫格，所以用i/3,j/3就可以定位到当前小宫格，再根据下标index即可更新。

参考代码

class Solution {
public:
    bool isValidSudoku(vector<vector<char>>& board) {
        int n=board.size();
        int m=board[0].size();
        //哈希表：记录每一行，每一列，每个小宫格出现的值的数字，这里可以用数组存即可
        int row[9][9]={0};
        int col[9][9]={0};
        int box[3][3][9]={0};//定位到小宫格(i/3,j/3)
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                //填充了数字的进行验证
                if(board[i][j]>='0'&&board[i][j]<='9')
                {
                //获取当前下标
                    int index=board[i][j]-'1';
                    //更新行
                    row[i][index]++;
                    //更新列
                    col[index][j]++;
                    //更新小宫格
                    box[i/3][j/3][index]++;
                    //判断更新值
                    if(row[i][index]>1||col[index][j]>1|| box[i/3][j/3][index]>1)
                    {
                        return false;
                    }
                }
            }
        }
        return true;
    }
   
};

73. 矩阵置零

题目描述

给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用原地算法。

样例一

在这里插入图片描述

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

样例二

在这里插入图片描述

输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]

思路一

最直接暴力的方法，先用二维数组标记原始数组有没有0元素，然后依次去更新。

参考代码

class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        int n=matrix.size();
        int m=matrix[0].size();
        //用二维数组标记原始数组有没有0元素
        vector<vector<int>> flag(n,vector<int> (m));
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(matrix[i][j]==0)
                {
                    flag[i][j]=1;
                }
            }
        }
        //根据标记数组去置对应行和对应列为0
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(flag[i][j]==1)
                {
                    set(matrix,i,j);
                }
            }
        }

    }
    void set(vector<vector<int>>& matrix,int i,int j)
    {
        int n=matrix.size();
        int m=matrix[0].size();
        for(int k=0;k<m;k++)
        {
            matrix[i][k]=0;
        }
        for(int k=0;k<n;k++)
        {
            matrix[k][j]=0;
        }
        

    }
};

思路二

感觉这个二维标记数组反而使得代码有点繁琐，可以用两个一维标记数组，反而在更新时更简单一点，这个也是暴力破解法：
首先遍历该数组一次，如果某个元素为 0，就将该元素所在的行和列所对应标记数组的位置置为 1。最后我们再次遍历该数组，用标记数组更新原数组即可。

参考代码

class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        int n=matrix.size();
        int m=matrix[0].size();
        //用两个数组分别标记原始数组有没有0元素
       vector<int> row(n);
       vector<int> col(m);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(matrix[i][j]==0)
                {
                    row[i]=1;
                    col[j]=1;
                }
            }
        }
        //根据标记数组去置对应行和对应列为0
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(row[i]||col[j])
                {
                    matrix[i][j]=0;
                }
            }
        }

    }
   
};

思路三

前面两个方法的空间复杂度都是O（m+n),所以为了减少空间复杂度，可以用矩阵的第一行和第一列代替标记数组来标记，达到O（1）的空间复杂度，但是这样第一行和第一列的原始值会被修改，所以我们要用两个标记变量来标记原来的第一行和第一列是否有0元素。
实现：先处理第一行和第一列是否有0元素，存储在两个标记变量中，然后判定其他行和列的0元素情况存储在第一行和第一列中，作为标记。最后根据第一行和第一列的当前值（标记结果）去更新其他行和其他列，以及根据两个变量去更新第一行第一列。

参考代码

class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        int m=matrix.size();
        int n=matrix[0].size();
        //两个标记变量存储第一行，第一列的0元素情况
        int row=0,col=0;
        //先判断第一列
        for(int i=0;i<m;i++)
        {
            if(matrix[i][0]==0)
            {
                col=1;
            }
        }
        //判断第一行
        for(int j=0;j<n;j++)
        {
            if(matrix[0][j]==0)
            {
                row=1;
            }

        }
        //判断其他行和列存储在第一行第一列
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                if(matrix[i][j]==0)
                {
                    matrix[i][0]=0;
                    matrix[0][j]=0;
                }
            }
        }
        //根据标记在第一行和第一列的结果去置其他行和其他列为0
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                if(!matrix[i][0]||!matrix[0][j])
                {
                    matrix[i][j]=0;
                }
            }
        }
        //更新第一行
        if(row)
        {
            for(int j=0;j<n;j++)
            {
                matrix[0][j]=0;
            }

        }
         //更新第一列
        if(col)
        {
             for(int i=0;i<m;i++)
            {
                matrix[i][0]=0;
            }
        }
       
       

    }
   
};