2020_9_15每日一题 解数独

编写一个程序，通过已填充的空格来解决数独问题。

一个数独的解法需遵循如下规则：

数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
空白格用 ‘.’ 表示。

一个数独。

答案被标成红色。

Note:

给定的数独序列只包含数字 1-9 和字符 ‘.’ 。 你可以假设给定的数独只有唯一解。 给定数独永远是 9x9 形式的。

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/sudoku-solver
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

经典回溯法。到某个空位的时候先查找当前空位都可以填什么数字，然后挨个填一下试试。如果所有可能的数字填了都解不开数独就往前回溯。回溯的时候记得把当前位置再改成空位，不然会影响之后的判断(吃了好几次亏)。

class Solution {
    boolean[] findPssibleNums(char[][] board, int row, int col) {
        boolean[] ret = new boolean[9];//懒得初始化 true 表示占用
        for(int i = 0; i < 9; ++i) {
            if(board[row][i] != '.') {
                ret[board[row][i] - '1'] = true;
            }
            if(board[i][col] != '.') {
                ret[board[i][col] - '1'] = true;
            }
        }
        int boxRow = row / 3, boxCol = col / 3;

        for(int i = 0; i < 3; ++i) 
        for(int j = 0; j < 3; ++j){
            char cur = board[boxRow * 3 + i][boxCol * 3 + j];
            if(cur != '.') {
                ret[cur - '1'] = true;
            }
        }
        return ret;
    } 

    private boolean solveRec(char[][] board, int row, int col) {
        if(col == 9) {
            if(row == 8)
                return true;
            else {
                col = 0;
                row = row + 1;
            }
        }

        //不为空 直接去找下一个点
        if(board[row][col] != '.')
            return solveRec(board, row, col + 1);
        else {
            boolean[] impossable = findPssibleNums(board, row, col);
            //System.out.println("row = " + row + " col = " + col);
            //System.out.println("impossable = " + Arrays.toString(impossable));
            for(int i = 0; i < 9; ++i) {
                if(impossable[i] == false) {
                    board[row][col] = (char)(i + '1');
                    if(solveRec(board, row, col + 1))
                        return true;
                }
            }
        }
        board[row][col] = '.';
        return false;
    }

    public void solveSudoku(char[][] board) {
        solveRec(board, 0, 0);
    }
}

看了下题解，思路都是这个思路，不过可以用各种方法来加快获取可能数字集的速度。实现了一个用静态变量记录被占用的数字，每次找可能解的时候从静态变量找。顺便实现了用位来记录，依然是，清理的时候不光要清理记录中的数，由于递归函数中有判断板子是否为空，清理的时候也要把板子上的清了(发了半天呆才反应过来)

class Solution {
    //试着用位运算加速
    int[] rows;
    int[] cols;
    int[][] blocks;

    int findPssibleNums(int row, int col) {
        return rows[row] | cols[col] | blocks[row / 3][col / 3];
    } 

    private boolean solveRec(char[][] board, int row, int col) {
        if(col == 9) {
            if(row == 8)
                return true;
            else {
                col = 0;
                row = row + 1;
            }
        }

        //不为空 直接去找下一个点
        if(board[row][col] != '.')
            return solveRec(board, row, col + 1);
        else {
            int impossable = findPssibleNums(row, col);
            for(int i = 0; i < 9; ++i) {
                if(((~(impossable >> i)) & 1) == 1) {
                    board[row][col] = (char)(i + '1');
                    set(row, col, (char)(i + '1'));
                    if(solveRec(board, row, col + 1))
                        return true;
                    clear(row, col, (char)(i + '1'));
                }
            }
        }
        board[row][col] = '.';
        return false;
    }

    void set(int row, int col, char num) {
        int bitNum = 1 << (num - '1');
        rows[row] |= bitNum;
        cols[col] |= bitNum;
        blocks[row / 3][col / 3] |= bitNum;
    }

    void clear(int row, int col, char num) {
        int bitNum = ~(1 << (num - '1'));
        rows[row] &= bitNum;
        cols[col] &= bitNum;
        blocks[row / 3][col / 3] &= bitNum;
    }

    void pre(char[][] board) {
        for(int i = 0; i < 9; ++i)
        for(int j = 0; j < 9; ++j) {
            if(board[i][j] != '.') {
                set(i, j, board[i][j]);
            }
        }
    }

    public void solveSudoku(char[][] board) {
        rows = new int[9];
        cols = new int[9];
        blocks = new int[3][3];
        pre(board);

        solveRec(board, 0, 0);
    }
}

这种做法需要预处理一下，先把板子上最初的数加到静态变量中去。一个可能的优化是对于板子上一开始就只有一个可能性的点，就不用在回溯的过程中处理了，在预处理的时候就可以填上：

class Solution {
    //试着用位运算加速
    int[] rows;
    int[] cols;
    int[][] blocks;

    int findPssibleNums(int row, int col) {
        return rows[row] | cols[col] | blocks[row / 3][col / 3];
    } 

    private boolean solveRec(char[][] board, int row, int col) {
        if(col == 9) {
            if(row == 8)
                return true;
            else {
                col = 0;
                row = row + 1;
            }
        }

        //不为空 直接去找下一个点
        if(board[row][col] != '.')
            return solveRec(board, row, col + 1);
        else {
            int impossable = findPssibleNums(row, col);
            for(int i = 0; i < 9; ++i) {
                if(((~(impossable >> i)) & 1) == 1) {
                    board[row][col] = (char)(i + '1');
                    set(row, col, (char)(i + '1'));
                    if(solveRec(board, row, col + 1))
                        return true;
                    clear(row, col, (char)(i + '1'));
                }
            }
        }
        board[row][col] = '.';
        return false;
    }

    void set(int row, int col, char num) {
        int bitNum = 1 << (num - '1');
        rows[row] |= bitNum;
        cols[col] |= bitNum;
        blocks[row / 3][col / 3] |= bitNum;
    }

    void clear(int row, int col, char num) {
        int bitNum = ~(1 << (num - '1'));
        rows[row] &= bitNum;
        cols[col] &= bitNum;
        blocks[row / 3][col / 3] &= bitNum;
    }

    void pre(char[][] board) {
        for(int i = 0; i < 9; ++i)
        for(int j = 0; j < 9; ++j) {
            if(board[i][j] != '.') {
                set(i, j, board[i][j]);
            }
        }
        //先把唯一可能的数给填上
        for(int i = 0; i < 9; ++i)
        for(int j = 0; j < 9; ++j) {
            for(int num = 0; num < 9; ++num) {
                int poss = findPssibleNums(i, j);
                if(poss == 1 << i) {
                    set(i, j, (char)('1' + num));
                    board[i][j] = (char)('1' + num);
                    break;
                }
            }
        }
    }

    public void solveSudoku(char[][] board) {
        rows = new int[9];
        cols = new int[9];
        blocks = new int[3][3];
        pre(board);

        solveRec(board, 0, 0);
    }
}

第一次提交4ms，后两次3ms，还算不错
题解中位运算更有技巧性一些，我写的还是有点民工了，好在能用