Leetcode P36 Java模拟解决此问题，思路清晰明了

Leetcode P36 Java模拟解决此问题，思路清晰明了

ideas

首先我们对board二维数组进行遍历，如果遇见字符.就跳出当前循环进入下一次循环

        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                if (board[i][j] == '.'){
                    continue;
                }
                
                //判断当前行师傅有重复数字
                ...........
                
                //判断当前列是否存在重复元素
                ......................
                
                //判断九宫格
                ......................
            }
        }

接下来判断当前行是否存在重复数字

                //判断当前行是否有重复数字
                for (int k = 0; k < board[i].length; k++) {
                    if (k != j && board[i][j] == board[i][k]){
                        return false;
                    }
                }

接下来判断当前列是否存在重复数字

                //判断当前列是否存在重复元素
                for (int k = 0; k < board.length; k++) {
                    if (k != i && board[k][j] == board[i][j]){
                        return false;
                    }
                }

接下来开始判断当前九宫格是否存在重复数字

首先我们要找到定位点，就是找到大于i和j的最小的可以整除3的数字

        while (i >= tmpi){

            tmpi+=3;
        }

        while (j >= tmpj){
            tmpj+=3;
        }

最后tmpi和tmpj计算出来的值是3*3的正方形的右下角，那么我们就可以得出当前下标所属于的3X3的正方形了，我们就判断当前正方形是否存在重复元素，

        //判断这个区域是否存在和当前元素重复的
        for (int k = tmpi-1; k >= tmpi-3 ; k--) {
            for (int l = tmpj-1; l >= tmpj-3 ; l--) {
                if (l == j && k == i || board[k][l] == '.'){
                    continue;
                }

                if (tmp == board[k][l]){
                   // System.out.println(board[k][l]);
                   // System.out.println(k+"and"+l);
                   // System.out.println(i+"and"+j);
                    return true;
                }
            }
        }

code

class Solution {
    public boolean isValidSudoku(char[][] board) {
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                if (board[i][j] == '.'){
                    continue;
                }

                //判断当前行是否有重复数字
                for (int k = 0; k < board[i].length; k++) {
                    if (k != j && board[i][j] == board[i][k]){
                        return false;
                    }
                }

                //判断当前列是否存在重复元素
                for (int k = 0; k < board.length; k++) {
                    if (k != i && board[k][j] == board[i][j]){
                        return false;
                    }
                }

                //判断九宫格
                if (check(board,i,j)){

                    return false;
                }
            }
        }
        
        return true;
    }

    public boolean check(char[][] board,int i ,int j){
        char tmp = board[i][j];

        //找到大于等于i和j最小的3的倍数
        int tmpi = 3;
        int tmpj = 3;
        while (i >= tmpi){

            tmpi+=3;
        }


        while (j >= tmpj){
            tmpj+=3;
        }
        //System.out.println("传入的i="+i+" and j="+j+"他的边界k="+(tmpi-1)+"他的边界j="+(tmpj-1));

        //判断这个区域是否存在和当前元素重复的
        for (int k = tmpi-1; k >= tmpi-3 ; k--) {
            for (int l = tmpj-1; l >= tmpj-3 ; l--) {
                if (l == j && k == i || board[k][l] == '.'){
                    continue;
                }

                if (tmp == board[k][l]){
                   // System.out.println(board[k][l]);
                   // System.out.println(k+"and"+l);
                   // System.out.println(i+"and"+j);
                    return true;
                }
            }
        }

        return false;
    }
}