【leetcode-回溯】有效的数独/解数独

有效的数独

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

上图是一个部分填充的有效的数独。
数独部分空格内已填入了数字，空白格用 ‘.’ 表示。

示例 1:
输入:
[
[“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:
输入:
[
[“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 存在, 因此这个数独是无效的。

模拟

class Solution {
    public boolean isValidSudoku(char[][] board) {
        boolean[][] rows = new boolean[9][9];
        boolean[][] columns = new boolean[9][9];
        boolean[][] boxes = new boolean[9][9];
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                int num = board[i][j] - '1';
                if (num == -3) 
                    continue;
                int index = (i / 3) * 3 + j / 3;
                if (rows[i][num] || columns[j][num] || boxes[index][num])
                    return false;
                
                rows[i][num] = true;
                columns[j][num] = true;
                boxes[index][num] = true;
            }
        }
        return true;
    }
}

解数独

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

回溯

class Solution {
    private boolean[][] rows = new boolean[9][9];
    private boolean[][] columns = new boolean[9][9];
    private boolean[][][] boxes = new boolean[3][3][9];
    private boolean valid = false;
    private List<int[]> spaces = new ArrayList<int[]>();

    public void solveSudoku(char[][] board) {
        
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (board[i][j] == '.') {
                    spaces.add(new int[]{i, j});
                } else {
                    int digit = board[i][j] - '1';
                    rows[i][digit] = columns[j][digit] = boxes[i/3][j/3][digit] = true;
                }
            }
        }
        backtrack(board, 0);
    }

    private void backtrack(char[][] board, int pos) {
        if (pos == spaces.size()) {
            valid = true;
            return;
        }
        int[] space = spaces.get(pos);
        int i = space[0], j = space[1];
        for (int digit = 0; digit < 9 && !valid; ++digit) {
            if (!rows[i][digit] && !columns[j][digit] && !boxes[i/3][j/3][digit]) {
                rows[i][digit] = columns[j][digit] = boxes[i/3][j/3][digit] = true;
                board[i][j] = (char) (digit + '1');
                backtrack(board, pos + 1);
                rows[i][digit] = columns[j][digit] = boxes[i/3][j/3][digit] = false;
            }
        }
    }
}

基于位运算的回溯

使用位运算存储取代数组
数 b 的二进制表示的第 i 位（从低到高，最低位为第 0 位）为 1，当且仅当数字 i+1 已经出现过。例如当 b 的二进制表示为 $(011000100{)}_2$时，就表示数字 3，7，8 已经出现过。

• 对于第 i 行第 j 列的位置，$line[i]\mid column[j]\mid block[\lfloor i/3\rfloor ][\lfloor j/3\rfloor ]$ 中第 k 位为 1，表示该位置不能填入数字 k+1。如果我们对这个值进行 ∼ 按位取反运算，那么第 k 位为 1 就表示该位置可以填入数字 k+1，我们就可以通过寻找 1 来进行枚举。由于在进行按位取反运算后，这个数的高位也全部变成了 1，而这是我们不应当枚举到的，因此我们需要将这个数和 $(111111111{)}_2=(\text{1FF}{)}_{16}$ 进行按位与运算 &&，将所有无关的位置为 0；
• 我们可以使用按位异或运算 ∧，将第 i 位从 0 变为 1，或从 1 变为 0。
• 我们可以用 b & (−b) 得到 b 二进制表示中最低位的 1，这是因为 (-b) 在计算机中以补码的形式存储，它等于 ∼b+1。b 如果和 ∼b 进行按位与运算，那么会得到 0，但是当 ∼b 增加 1 之后，最低位的连续的 1 都变为 0，而最低位的 0 变为 1，对应到 b 中即为最低位的 1，因此当 b 和 ∼b+1 进行按位与运算时，只有最低位的 1 会被保留。

class Solution {
    private int[] rows = new int[9];
    private int[] columns = new int[9];
    private int[][] boxes = new int[3][3];
    private boolean valid = false;
    private List<int[]> spaces = new ArrayList<int[]>();

    public void solveSudoku(char[][] board) {
        for (int i = 0; i < 9; ++i) {
            for (int j = 0; j < 9; ++j) {
                if (board[i][j] != '.') {
                    int digit = board[i][j] - '1';
                    flip(i, j, digit);
                }
            }
        }

        boolean modified = true;
        while (modified) {
            modified = false;
            for (int i = 0; i < 9; ++i) {
                for (int j = 0; j < 9; ++j) {
                    if (board[i][j] == '.') {
                        int mask = ~(rows[i] | columns[j] | boxes[i / 3][j / 3]) & 0x1ff;
                        if ((mask & (mask - 1)) == 0) {
                            int digit = Integer.bitCount(mask - 1);
                            flip(i, j, digit);
                            board[i][j] = (char) (digit + '1');
                            modified = true;
                        }
                    }
                }
            }
        }

        for (int i = 0; i < 9; ++i) {
            for (int j = 0; j < 9; ++j) {
                if (board[i][j] == '.')
                    spaces.add(new int[]{i, j});
            }
        }

        backtrack(board, 0);
    }

    public void backtrack(char[][] board, int pos) {
        if (pos == spaces.size()) {
            valid = true;
            return;
        }

        int[] space = spaces.get(pos);
        int i = space[0], j = space[1];
        int mask = ~(rows[i] | columns[j] | boxes[i / 3][j / 3]) & 0x1ff;
        for (; mask != 0 && !valid; mask &= (mask - 1)) {
            int digitMask = mask & (-mask);
            int digit = Integer.bitCount(digitMask - 1);
            flip(i, j, digit);
            board[i][j] = (char) (digit + '1');
            backtrack(board, pos + 1);
            flip(i, j, digit);
        }
    }

    public void flip(int i, int j, int digit) {
        rows[i] ^= (1 << digit);
        columns[j] ^= (1 << digit);
        boxes[i / 3][j / 3] ^= (1 << digit);
    }
}