LeetCode--解数独(回溯法)

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

 

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

数字 1-9 在每一行只能出现一次。

数字 1-9 在每一列只能出现一次。

数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

空白格用 '.' 表示。

 

一个数独。

 

答案被标成红色。

 

Note:

给定的数独序列只包含数字 1-9 和字符 '.' 。

你可以假设给定的数独只有唯一解。

给定数独永远是 9x9 形式的。

 

回溯法 思路

回溯法
public static void solveSudoku(char[][] board) {
    if (board == null) {
        return ;
    }
    solve(board);
    System.out.println(board);
}
public static boolean solve(char[][] board){
    for(int i=0;i<board.length;i++){
        //这里可以写死9
        for (int j =0;j<board[0].length;j++){
            if(board[i][j] == '.'){
                //如果是空的话那么可以填
                for(int m =1;m<=9;m++){
                    //把1-9的数字传进去
                    if(valid(board,i,j,(char)(m+'0'))){
                        //如果是合法的，那么久把它传进去
                        board[i][j] =(char) (m+'0');
                        //这里下面开始递归
                        if(solve(board)){
                            //这里的矩阵已经是改变了的矩阵了
                            return true;
                        }else {
                            board[i][j] = '.';
                        }

                    }
                }
                return false;
            }
        }
    }
    return true;
}
//验证合法
private static boolean valid(char[][] board,int row,int col,char c){
    //这是判断大括号里面的9宫格是否合法
    for(int i =0;i<9;i++){
        //判断行
        if(board[i][col] != '.' && board[i][col] == c){
            return false;
        }
        //判断列
        if(board[row][i]!= '.' && board[i][col] == c){
            return false;
        }
        //以下是判断在小的9宫格里面的位置以及验证在9宫格是否合法
        int x = (int) (3 * Math.floor(row / 3) + Math.floor(i / 3));
        int y = (int) (3 * Math.floor(col / 3) + Math.floor(i % 3));
        if(board[x][y] != '.' && board[x][y] == c){
            return false;
        }
    }
    return true;
}

主函数

/**
 * @Auther: liuhaidong
 * Data: 2019/9/23 0023、16:40
 * Description:
 * @version: 1.0
 */
public class solveSudoku {
    public static void main(String[] args) {
        System.out.println("请输入字符串");
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String splitstr = str.substring(1,str.length()-1);
        char[][] board = new char[9][9];
        String[] strings = new String[9];
        int j =0;
        //这里的j是strings的赋值，又是字符数组board的赋值
        int a = 0, b = 0;
        for (int index = 0; index < splitstr.length(); index++) {
            //System.out.println(splitstr);
            if ('[' == splitstr.charAt(index)) {
                a = index;
            }
            else if (']' == splitstr.charAt(index))
            {
                b = index;
                strings[j] = splitstr.substring(a+1,b);
                //这个时候已经得到第一个字符串
                //去掉所有的引号
                strings[j] = strings[j].replaceAll("\"", "");
                int m =0;
                for(int i =0;i<strings[j].length();i++){
                    if(strings[j].charAt(i) == ','){
                        continue;
                    }else {
                        board[j][m] = strings[j].charAt(i);
                        ++m;
                        if(m==9){
                            break;
                        }
                    }
                }
                m =0;
                ++j;
                splitstr = splitstr.substring(b + 1, splitstr.length());
                index =0;
                a =0;
                b =0;
            }

        }
        solveSudoku(board);
        for(int m =0;m<9;m++){
            System.out.print("[");
            for(int n =0;n<9;n++) {
                if (n == 8) {
                    System.out.print(board[m][n]);
                } else {
                    System.out.print(board[m][n] + " ");
                }
            }
            System.out.println("]");
        }
    }

结果