leetcode解数独sudoku-solver——二进制解法

解数独sudoku-solver

代码一

package sudoku_solver;

import java.util.ArrayList;
import java.util.List;

/**
 * sudoku-solver
 *
 */
public class Solution {
    private boolean[][] line = new boolean[9][9];//
    private boolean[][] column = new boolean[9][9];
    private boolean[][][] block = 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] == '.') {        //给定的数独序列只包含数字 1-9 和字符 '.'
                    spaces.add(new int[]{i, j});
                } else {
                    int digit = board[i][j] - '0' - 1;//获取当前位置的数字,减去0是为了自动转型,减去1是为了对应数组下标
                    line[i][digit] = column[j][digit] = block[i / 3][j / 3][digit] = true;
                }
            }
        }
        //当我们结束了遍历过程之后，就可以开始递归枚举。
        dfs(board, 0);
    }

    public void dfs(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 (!line[i][digit] && !column[j][digit] && !block[i / 3][j / 3][digit]) {
                line[i][digit] = column[j][digit] = block[i / 3][j / 3][digit] = true;
                board[i][j] = (char) (digit + '0' + 1);//从0-9尝试,加字符0为了自动转型,加1为了对应数字
                dfs(board, pos + 1);
                //回溯
                line[i][digit] = column[j][digit] = block[i / 3][j / 3][digit] = false;
            }
        }
    }
    
    private void printBoard(char[][] board) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                System.out.print(board[i][j] + " ");
            }
            System.out.println();
        }
    }
    
    public static void main(String[] args) {
        char[][] board = new char[][]{
                {'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'}
        };
        Solution solution = new Solution();
        solution.printBoard(board);
        solution.solveSudoku(board);
        solution.printBoard(board);
    }
}

代码二

package sudoku_solver;

public class Solution2 {
    public void solveSudoku(char[][] board) {
        /**
         * 记录某行，某位数字是否已经被摆放
         */
        boolean[][] row = new boolean[9][9];
        /**
         * 记录某列，某位数字是否已经被摆放
         */
        boolean[][] col = new boolean[9][9];
        /**
         * 记录某 3x3 宫格内，某位数字是否已经被摆放
         */
        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';
                    row[i][num] = true;
                    col[j][num] = true;
                    // blockIndex = i / 3 * 3 + j / 3，取整
                    block[i / 3 * 3 + j / 3][num] = true;
                }
            }
        }
        dfs(board, row, col, block, 0, 0);
    }

    private boolean dfs(char[][] board, boolean[][] row, boolean[][] col, boolean[][] block, int i, int j) {
        // 找寻空位置
        while (board[i][j] != '.') {
            if (++j >= 9) {
                i++;
                j = 0;
            }
            if (i >= 9) {
                return true;
            }
        }
        for (int num = 0; num < 9; num++) {
            int blockIndex = i / 3 * 3 + j / 3;
            if (!row[i][num] && !col[j][num] && !block[blockIndex][num]) {
                // 递归
                board[i][j] = (char) ('1' + num);
                row[i][num] = true;
                col[j][num] = true;
                block[blockIndex][num] = true;
                if (dfs(board, row, col, block, i, j)) {
                    return true;
                } else {
                    // 回溯
                    row[i][num] = false;
                    col[j][num] = false;
                    block[blockIndex][num] = false;
                    board[i][j] = '.';
                }
            }
        }
        return false;
    }

    private void printBoard(char[][] board) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                System.out.print(board[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        char[][] board = new char[][]{
                {'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'}
        };
        Solution2 solution = new Solution2();
        solution.printBoard(board);
        solution.solveSudoku(board);
        solution.printBoard(board);
    }
}

代码三——二进制解法

class Solution {
    private int[] line = new int[9];
    private int[] column = new int[9];
    private int[][] block = 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] == '.') {
                    spaces.add(new int[]{i, j});
                } else {
                    int digit = board[i][j] - '0' - 1;
                    flip(i, j, digit);
                }
            }
        }

        dfs(board, 0);
    }

    public void dfs(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 = ~(line[i] | column[j] | block[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 + '0' + 1);
            dfs(board, pos + 1);
            flip(i, j, digit);
        }
    }

    public void flip(int i, int j, int digit) {
        line[i] ^= (1 << digit);
        column[j] ^= (1 << digit);
        block[i / 3][j / 3] ^= (1 << digit);
    }
}

代码四

       //数独的长宽大小
        final int N = 9;
        //行
        private int[] rows = new int[N];
        //列
        private int[] cols = new int[N];
        //单元格
        private int[][] cells = new int[3][3];

        public void solveSudoku(char[][] board) {
            //统计未填的个数
            int count = 0;
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    char ch = board[i][j];
                    if (ch == '.') {
                        count++;
                    } else {
                        //如果已经有数字，把这个数字标记一下
                        fillNumber(i, j, ch - '1', true);
                    }
                }
            }
            //上面是一些计算前的准备工作，从这里开始调用回溯算法
            backtrace(board, count);
        }

        private boolean backtrace(char[][] board, int count) {
            //如果可填的位置为0，就是填完了，直接返回true
            if (count == 0) {
                return true;
            }
            //找到可选择数字比较少的位置
            int[] pos = getMinOkMaskCountPos(board);
            int x = pos[0], y = pos[1];
            //获取可选择数字比较少的位置的mask
            int mask = getMask(x, y);
            for (char c = '1'; c <= '9'; c++) {
                int index = c - '1';
                //判断这个位置是否可以填字符c
                if (testMask(mask, index)) {
                    //如果可填，就把字符c填入到这个位置中
                    fillNumber(x, y, index, true);
                    board[x][y] = c;
                    //如果成功直接返回
                    if (backtrace(board, count - 1))
                        return true;
                    //否则，撤销上面的操作
                    board[x][y] = '.';
                    fillNumber(x, y, index, false);
                }
            }
            return false;
        }

        //如果fill是true就把对应位置的数字从右边数第（n+1）位变为1，如果fill为false就把
        //对应位置的数字从右边数第（n+1）位变为0，
        private void fillNumber(int x, int y, int n, boolean fill) {
            if (fill) {
                int mask = 1 << n;
                rows[x] = rows[x] | mask;
                cols[y] = cols[y] | mask;
                cells[x / 3][y / 3] = cells[x / 3][y / 3] | mask;
            } else {
                int mask = ~(1 << n);
                rows[x] = rows[x] & mask;
                cols[y] = cols[y] & mask;
                cells[x / 3][y / 3] = cells[x / 3][y / 3] & mask;
            }
        }

        //当前位置的行，列，单元格进行与运算，运算的结果就是如果这个数字的
        //后面9位哪一个位置是0，就表示这个位置可以填对应的数字
        private int getMask(int x, int y) {
            return rows[x] | cols[y] | cells[x / 3][y / 3];
        }

        //统计上面的方法有多少位置还可以填
        private int getCount(int mask) {
            int count = 0;
            for (int i = 0; i < N; i++) {
                if ((mask & (1 << i)) == 0)
                    count++;
            }
            return count;
        }

        //判断mask从右边数第（index+1）个位置是否可以填入数字，
        //注意这里的index是从0开始，如果是0，就表示判断右边第1位
        //能不能填入数字
        private boolean testMask(int mask, int index) {
            return (mask & (1 << index)) == 0;
        }

        //统计所有的单元格，判断哪个单元格内可填数字比较少，就返回哪个单元格的坐标
        private int[] getMinOkMaskCountPos(char[][] board) {
            int[] res = new int[2];
            int min = 10;
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    if (board[i][j] == '.') {
                        int mask = getMask(i, j);
                        int count = getCount(mask);
                        if (count < min) {
                            min = count;
                            res[0] = i;
                            res[1] = j;
                        }
                    }
                }
            }
            return res;
        }

sdwwld