数独九宫格破解

/**
 * @Author: dai jiawei
 * @Date: 2021/6/9 17:35
 */
public class sudoku {

    public static void main(String[] args) {
        int[][] n = new int[][]{
                {0,2,0,0,0,3,0,0,0},
                {4,0,5,2,0,9,0,0,0},
                {0,0,7,0,0,8,5,3,2},
                {1,0,2,0,0,0,0,0,0},
                {0,8,0,0,0,0,0,2,0},
                {0,0,0,0,0,0,3,0,4},
                {9,1,3,5,0,0,0,4,0},
                {0,0,0,9,0,6,8,0,3},
                {0,0,0,3,0,0,0,7,0},
        };
        print(n);
        count(n);
    }

    private static void count(int[][] number){
        //判断一个格子中可以存放哪些数字
        int[][][] s = new int[9][9][9];
        for (int i = 0; i <s.length ; i++) {
            for (int j = 0; j <s[i].length ; j++) {
                int[] x = new int[]{1,2,3,4,5,6,7,8,9};
                s[i][j]=x;
            }
        }
        //根据初始条件去除格子中不能放的数字
        for (int i = 0; i < number.length; i++) {
            for (int j = 0; j <number[i].length ; j++) {
                int x =number[i][j];
                if(x!=0){
                    s[i][j] = new int []{0,0,0,0,0,0,0,0,0};

                    //清理横排和竖排
                    for (int k = 0; k < 9; k++) {
                        s[k][j][x-1] = 0;
                        s[i][k][x-1] = 0;
                    }

                    //清理宫格
                    int m = i/3*3;
                    int n = j/3*3;
                    for (int k = m ; k <m+3 ; k++) {
                        for (int l = n; l < n+3; l++) {
                            s[k][l][x-1] = 0;
                        }
                    }
                    s[i][j][x-1] =  number[i][j];
                }
            }
        }
        fill(number,s);
    }

    /**
     * @Author dai jiawei
     * @Description 填充数独
     * @Date 2021/6/10 13:45
     * @param number
     * @param s
     * @Return boolean
     **/
    private static boolean fill(int[][] number ,int[][][] s){
        //查找复杂度最低的空格
        List<Integer> minList = find(number,s);
        if(minList==null){
            print(s);
            return true;
        }
        System.out.println(minList.toString());
        int i = minList.get(0);
        int j = minList.get(1);
        System.out.println("复杂度最低的空格是："+i+","+j);

        for (int t = 2; t < minList.size(); t++) {
            int[][] n1 = new int[9][9];
            copy(number,n1);
            int[][][] s1= new int[9][9][9];
            copy(s,s1);

            int x =minList.get(t);
            System.out.println("执行分支是："+x);
            //清理横排和竖排
            for (int k = 0; k < 9; k++) {
                if(k!=i) {
                    s1[k][j][x - 1] = 0;
                    if(!judge(s1[k][j])){
                        continue;
                    }
                }
                if(k!=i) {
                    s1[i][k][x - 1] = 0;
                    if(!judge(s1[i][k])){
                        continue;
                    }
                }
            }

            //清理宫格
            int m = i/3*3;
            int n = j/3*3;
            for (int k = m ; k <m+3 ; k++) {
                for (int l = n; l < n+3; l++) {
                    if(k!=i&&l!=j) {
                        s1[k][l][x - 1] = 0;
                        if(!judge(s1[k][l])){
                            continue;
                        }
                    }
                }
            }

            s1[i][j] = new int []{0,0,0,0,0,0,0,0,0};
            s1[i][j][x-1] = x;
            n1[i][j]= x;
            //print(n1);
            //print(s1);
            if(fill(n1,s1)){
                return true;
            }
        }
        return false;
    }
    
    /**
     * @Author dai jiawei
     * @Description 判断数组中是否还有可能的数字
     * @Date 2021/6/10 12:42
     * @param n
     * @Return boolean
     **/
    private static boolean judge(int [] n){
        for (int i = 0; i < n.length; i++) {
            if(n[i]!=0){
                return true;
            }
        }
        return false;
    }

    /**
     * @Author dai jiawei
     * @Description 查找复杂度最低的空格
     * @Date 2021/6/10 13:39
     * @param n
     * @param s
     * @Return java.util.List<java.lang.Integer>
     **/
    private static List<Integer> find(int[][] n ,int[][][] s){
        int min = 9;
        List<Integer> result = null;
        for (int i = 0; i <n.length ; i++) {
            for (int j = 0; j <n[i].length ; j++) {
                if(n[i][j]==0){
                    int count = 0;
                    for (int k = 0; k <s[i][j].length ; k++) {
                        if(s[i][j][k]!=0){
                            count++;
                        }
                    }
                    if(min>count){
                        min = count;
                        result = new ArrayList<>();
                        result.add(i);
                        result.add(j);
                        for (int k = 0; k <s[i][j].length ; k++) {
                            if(s[i][j][k]!=0){
                                result.add(s[i][j][k]);
                            }
                        }
                    }
                }
            }
        }
        return result;
    }

    /**
     * @Author dai jiawei
     * @Description 打印九宫格
     * @Date 2021/6/10 10:21
     * @param n
     * @Return void
     **/
    private static void print(int[][] n){
        System.out.println("初始");
        System.out.println("___________________");
        for (int i = 0; i < n.length; i++) {
            System.out.print("|");
            for (int j = 0; j < n[i].length; j++) {
                System.out.print(n[i][j]==0?" ":n[i][j]);
                System.out.print("|");
            }
            System.out.println("");
        }
        System.out.println("-------------------");
    }

    /**
     * @Author dai jiawei
     * @Description 打印三维数组
     * @Date 2021/6/10 10:21
     * @param n
     * @Return void
     **/
    private static void print(int[][][] n){
        System.out.println("初始");
        System.out.println("___________________");
        for (int i = 0; i < n.length; i++) {
            System.out.print("|");
            for (int j = 0; j < n[i].length; j++) {
                for (int k = 0; k < n[i][j].length; k++) {
                    System.out.print(n[i][j][k]==0?"":n[i][j][k]);
                }
                System.out.print("|");
            }
            System.out.println("");
        }
        System.out.println("-------------------");
    }

    /**
     * @Author dai jiawei
     * @Description 对象克隆
     * @Date 2021/6/10 15:09
     * @param source
 * @param dest
     * @Return void
     **/
    private static void copy(Object source, Object dest) {
        if(source.getClass().isArray() && dest.getClass().isArray()) {
            for(int i = 0; i< Array.getLength(source); i++) {
                if(Array.get(source, i) != null && Array.get(source, i).getClass().isArray()) {
                    copy(Array.get(source, i), Array.get(dest, i));
                } else {
                    Array.set(dest, i, Array.get(source, i));
                }
            }
        }
    }

}