LeetCode 37 解数独 DFS

// 逐行填入数字,需要判断状态,这里借助别人的思路
// 跟之前判断数独合法类似,需要用到辅助数组
// row[i][k]表示第i行数字k是否使用
// col[j][k]表示第j列数字k是否使用
// metrix[x][k]表示第x个小9宫格中k是否使用编码方式
// 0 1 2
// 3 4 5
// 6 7 8
// 所以i和j与x的对应关系是 x = i / 3 * 3 + j / 3
// flag表示找到最终答案
// res用于递归过程保存最后答案



class Solution {

    private boolean flag = false;
    private char[][] res = new char[9][10];
    public void solveSudoku(char[][] board){
        boolean[][] row = new boolean[9][10];
        boolean[][] col = new boolean[9][10];
        boolean[][] metrix = new boolean[9][10];
        
        for (int i = 0; i < 9; i ++){
            for (int j = 0; j <= 9; j ++){
                row[i][j] = false;
                col[i][j] = false;
                metrix[i][j] = false;
            }
        }

        char c = 0;
        for (int i = 0 ;i < 9;i ++){ // 初始化
            for (int j = 0;j < 9; j ++){
                c = board[i][j];
                if (c >= '0' && c <= '9'){
                    row[i][c - '0'] = true;
                    col[j][c - '0'] = true;
                    metrix[i / 3 * 3 + j / 3][c - '0'] = true;
                }
            }
        }

        dfs(board, row, col, metrix, 0, 0);
        for (int i = 0;i < 9;i ++){
            for (int j = 0; j < 9; j ++){
                board[i][j] = res[i][j];
            }
        }
    }

    public void dfs(char[][] board, boolean[][] row, boolean[][] col, boolean[][] metrix, int i,int j){
        if (i >= 9){ // 返回条件,一定是把最后一行搜完了
            
            flag = true;

            for (int k = 0;k < 9;k ++){
                for (int l = 0; l < 9; l ++)
                    res[k][l] = board[k][l];
            }
            return; 
        }

        if (flag) return ;

        if (board[i][j] != '.'){ // 判断如果是数字就不用尝试了直接搜下一列或者下一行
            if (j < 8)
                dfs(board, row, col, metrix, i, j + 1); // 下一列
            else 
                dfs(board, row, col, metrix, i + 1, 0); // 下一行
            return ;
        }

        for (int k = 1;k <= 9; k++){
            if (!row[i][k] && !col[j][k] && !metrix[i / 3 * 3 + j / 3][k]){
                board[i][j] = (char)(k + '0');
                row[i][k] = true;
                col[j][k] = true;
                metrix[i / 3 * 3 + j / 3][k] = true;
                dfs(board, row, col, metrix, i, j);
                board[i][j] = '.'; // 回溯
                row[i][k] = false;
                col[j][k] = false;
                metrix[i / 3 * 3 + j / 3][k] = false;
            }
        }
    }
}