20210621力扣第36题：有效的数独(java)

题目

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

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 ‘.’ 表示。

注意：

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

示例 1：

输入：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


输入：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 存在, 因此这个数独是无效的。


提示：
board.length == 9
board[i].length == 9
board[i][j] 是一位数字或者 '.'

---

理解题目

开始遇到的时候没有头绪怎么做，想着寻找行与列就行，但是当时懒，看了很久没有头绪，就没写出来。

今天第二次看，就看了答案，我们要找到数独中 行/列/块 元素不重复，就能返回一个true。

一、答案

我看了官方的第一个解答，为了防止不重复，使用hashmap来进行存储元素，存储元素分了三个hashmap，分别是 行，列，块，一块是3*3，然后先遍历块，块中在遍历每一个格子，获取格子中的元素，找到值之后，对行列块的hashmap进行赋值，其中需要注意的是，根据行和列要找到块的坐标，块有9块坐标，所以要有一个推导的式子得到块坐标。

块坐标 = （行/3）*3 +列/3

最后检查每个 行列块 对应的值是否只有一个，多出一个就是重复了，那就返回false，没有就是true；

代码：

class Solution {
    public boolean isValidSudoku(char[][] board) {
        //3个条件
        // 每一行 每一列   3*3 只出现一次
        //9 * 9 的  不需要获取行列数 ，需要知道三个量  行 列  块

        //先建立 9个行 和 9个列  
        HashMap<Integer,Integer>[] rows = new HashMap[9];
        HashMap<Integer,Integer>[] columns = new HashMap[9];
        HashMap<Integer,Integer>[] boxes = new HashMap[9];

        //9个块再建立9宫格  Hashmap
        for(int i = 0; i <9;i++)
        {
            rows[i] = new HashMap<Integer,Integer>();//存放的是《值，行》
            columns[i] =new HashMap<Integer,Integer>();
            boxes[i] =new HashMap<Integer,Integer>();
        }


        //遍历 行
        //遍历 列
        //存放的是《值，行》  《值，列》 《值，哪一块》
        for(int i = 0;i<9;i++)
        {
            for(int j=0; j<9;j++)
            {
                char num = board[i][j];
                if(num!='.')
                {
                    int n = (int)num;
                    int box_index = (i/3)*3+j/3;

                    rows[i].put(n,rows[i].getOrDefault(n,0)+1);
                    columns[j].put(n,columns[j].getOrDefault(n,0)+1);
                    boxes[box_index].put(n,boxes[box_index].getOrDefault(n,0)+1);


                    if(rows[i].get(n)>1||columns[j].get(n)>1||boxes[box_index].get(n)>1)
                    //取的值就是n对应的value，每个值初始化是0，最多+1 等于1  多了的话就错了
                    {
                        return false;
                    }

                }
            }
        }

        return true;

    }
}

总结

第一次结题的时候不会，第二次看的时候就能明了很多，评论中也有很多不错的答案，官方给的答案比较好理解，还有一些数组的答案，我看到热评第一个用的布尔类型的数组，每个初始值都是false，遍历每一个不是‘.’的，然后，将当前值赋值为false，要是遍历时候又经过此处，就返回false。我也来尝试下代码：

class Solution {
    public boolean isValidSudoku(char[][] board) {
        boolean[][] col = new boolean[9][9];
        boolean[][] row = new boolean[9][9];
        boolean[][] block = new boolean[9][9];  

        for(int i = 0 ; i < 9 ; i++)
        {
            for(int j = 0 ; j< 9 ; j++)
            {
                if(board[i][j] != '.')
                {
                    int num = board[i][j] - '1';//放个中的数字 和数组中的行列对应 所以减1
                    int block_index = i/3*3+j/3;
                    if(col[i][num]||row[j][num]||block[block_index][num])
                    {
                        return false;
                    }
                    else{
                        col[i][num] = true;
                        row[j][num]= true;
                        block[block_index][num]= true;
                    }
                }
            }
        }    

        return true;  

    }
}

这个布尔类型 是二维数组。二维数组中第一个是行，第二个是 值所对应的列，想象一下，每个都是9*9 的一个数组，所以 row col block数组都有81个格子，把值放进去，值一重复就会进入 那个false的语句，就出错了。

以上两种是比较好理解的方法，我看到一个题目整理里面把这道题归结为回溯法，但是评论中好像没人使用回溯法，可能是整理错了或者这道题这样遍历更为简单，时间复杂度是O（1）。