数独程序求解世界最难数独——JAVA版

已于 2022-08-19 21:00:51 修改
阅读量539 收藏
点赞数
文章标签： java 算法 c++
于 2022-08-19 21:00:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianwangwxm/article/details/126431687
版权

目录

号称世界最难的数独

在这里插入图片描述

程序源码

import java.util.ArrayList;
import java.util.HashSet;

public class Main {
    private static final int MAX_GUESS_COUNT = 4096;
    private static int guessCount = 0;

    private static long startTime;

    private static void guessOneUnit(Sudoku sudoku) {
        if (++guessCount > MAX_GUESS_COUNT) {
            System.err.println("sudoku can't find the answer after " + guessCount + " times' guess so have to exit");
            sudoku.printEx(true);

            long endTime = System.currentTimeMillis();
            System.out.println("sudoku costs " + (endTime - startTime) + "ms to analyze this problem");
            System.exit(-1);
        }

        Sudoku.UnitToGuess unitToGuess = sudoku.fetchOneUnitToGuess();
        if (unitToGuess == null) {
            sudoku.printEx(true);
            System.err.println("sudoku enter a impossible situation and has to exit");
            return;
        }

        for (Integer e : unitToGuess.getOnes()) {
            Sudoku sudokuNew = sudoku.clone();
            sudokuNew.setOneUnit(unitToGuess.getRowIndex(), unitToGuess.getColIndex(), e);
            sudokuNew.printEx(true);
            if (sudokuNew.setUnitLoop()) {
                guessOneUnit(sudokuNew);
            }
        }
    }

    public static void solve(String input) {
        String[] lines = input.split("\\n");
        int[][] matrix = new int[Sudoku.LINE_UNIT_COUNT][Sudoku.LINE_UNIT_COUNT];
        for (int i = 0; i < Sudoku.LINE_UNIT_COUNT; ++i) {
            String[] units = lines[i].split(",");
            for (int j = 0; j < Sudoku.LINE_UNIT_COUNT; ++j) {
                matrix[i][j] = Integer.parseInt(units[j]);
            }
        }

        Sudoku sudoku = new Sudoku(matrix);
        sudoku.print("----------------original sudo matrix----------------");

        sudoku.initArray();
        sudoku.printEx(true);

        sudoku.setUnitLoop();
        guessOneUnit(sudoku);
    }

    public static class Sudoku implements Cloneable {
        public static final int LINE_MATRIX_UNIT_COUNT = 3;
        public static final int MATRIX_LINT_UNIT_COUNT = LINE_MATRIX_UNIT_COUNT;
        public static final int LINE_MATRIX_COUNT = LINE_MATRIX_UNIT_COUNT;
        public static final int MATRIX_UNIT_COUNT = LINE_MATRIX_UNIT_COUNT * LINE_MATRIX_UNIT_COUNT;
        public static final int LINE_UNIT_COUNT = MATRIX_UNIT_COUNT;

        public static final int PRINT_STEP_COUNT = 2000;

        private int[][] matrix;
        private ArrayList<Integer>[][] matrixEx;

        private HashSet<Integer>[] matrixRow;
        private HashSet<Integer>[] matrixCol;

        private HashSet<Integer>[][] matrixBlocks;

        private int finish;
        private int effective;
        private int empty;

        private static int index = 0;

        public Sudoku() {
            this(new int[LINE_UNIT_COUNT][LINE_UNIT_COUNT]);
        }

        public Sudoku(int[][] matrix) {
            this.finish = 0;
            this.effective = 0;
            this.empty = LINE_UNIT_COUNT * LINE_UNIT_COUNT;

            this.matrix = new int[LINE_UNIT_COUNT][LINE_UNIT_COUNT];
            this.matrixEx = new ArrayList[LINE_UNIT_COUNT][LINE_UNIT_COUNT];

            this.matrixRow = new HashSet[LINE_UNIT_COUNT];
            this.matrixCol = new HashSet[LINE_UNIT_COUNT];

            this.matrixBlocks = new HashSet[LINE_MATRIX_COUNT][LINE_MATRIX_COUNT];

            for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                for (int j = 0; j < LINE_UNIT_COUNT; ++j) {
                    this.matrix[i][j] = matrix[i][j];
                    this.matrixEx[i][j] = new ArrayList<>();
                    if (matrix[i][j] != 0) {
                        --this.empty;
                        ++this.finish;
                    }
                }
            }

            for (int k = 0; k < LINE_UNIT_COUNT; ++k) {
                matrixRow[k] = new HashSet<>();
                matrixCol[k] = new HashSet<>();
            }

            for (int i = 0; i < LINE_MATRIX_COUNT; ++i) {
                for (int j = 0; j < LINE_MATRIX_COUNT; ++j) {
                    matrixBlocks[i][j] = new HashSet<>();
                }
            }
        }

        public Sudoku clone() {
            Sudoku sudoku = new Sudoku();

            sudoku.empty = empty;
            sudoku.effective = effective;
            sudoku.finish = finish;

            for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                for (int j = 0; j < LINE_UNIT_COUNT; ++j) {
                    sudoku.matrix[i][j] = matrix[i][j];
                    for (Integer e : matrixEx[i][j]) {
                        sudoku.matrixEx[i][j].add(e);
                    }
                }
            }

            for (int k = 0; k < LINE_UNIT_COUNT; ++k) {
                for (Integer e : matrixRow[k]) {
                    sudoku.matrixRow[k].add(e);
                }

                for (Integer e : matrixRow[k]) {
                    sudoku.matrixRow[k].add(e);
                }
            }

            for (int i = 0; i < LINE_MATRIX_COUNT; ++i) {
                for (int j = 0; j < LINE_MATRIX_COUNT; ++j) {
                    for (Integer e : matrixBlocks[i][j]) {
                        sudoku.matrixBlocks[i][j].add(e);
                    }
                }
            }

            return sudoku;
        }

        private ArrayList<Integer> getInitUnit() {
            ArrayList<Integer> unit = new ArrayList<>();
            for (int i = 1; i <= LINE_UNIT_COUNT; ++i) {
                unit.add(i);
            }
            return unit;
        }

        private ArrayList<Integer> getInitUnitWithValue(int i) {
            ArrayList<Integer> unit = new ArrayList<>();
            unit.add(i);
            return unit;
        }

        private void initArray() {
            for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                for (int j = 0; j < LINE_UNIT_COUNT; ++j) {
                    if (matrix[i][j] != 0) {
                        matrixEx[i][j] = getInitUnitWithValue(matrix[i][j]);
                        matrixRow[i].add(matrix[i][j]);
                        matrixCol[j].add(matrix[i][j]);
                        matrixBlocks[i / LINE_MATRIX_UNIT_COUNT][j / LINE_MATRIX_UNIT_COUNT].add(matrix[i][j]);
                    }
                }
            }

            for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                for (int j = 0; j < LINE_UNIT_COUNT; ++j) {
                    if (matrix[i][j] == 0) {
                        matrixEx[i][j] = getInitUnit();
                    }
                }
            }
        }

        private void print(String title) {
            System.out.println(title);
            System.out.println("empty:" + empty + ",finish:" + finish + ",effective:" + effective);

            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                for (int j = 0; j < LINE_UNIT_COUNT; ++j) {
                    if (matrix[i][j] != 0) {
                        stringBuilder.append(" ").append(matrix[i][j]).append(" ");
                    } else {
                        stringBuilder.append("   ");
                    }

                    if (j != LINE_UNIT_COUNT - 1) {
                        if (j % 3 == 2) {
                            stringBuilder.append('║');
                        } else {
                            stringBuilder.append('│');
                        }
                    }
                }
                stringBuilder.append(System.lineSeparator());
                if (i != LINE_UNIT_COUNT - 1) {
                    boolean isDouble = i % 3 == 2;
                    printRowLine(isDouble, stringBuilder);
                }
            }

            stringBuilder.append(System.lineSeparator());
            System.out.println(stringBuilder);
        }

        private void printRowLine(boolean isDouble, StringBuilder stringBuilder) {
            String edge;
            char cross1;
            char cross2;
            if (isDouble) {
                edge = "═══";
                cross1 = '╪';
                cross2 = '╬';
            } else {
                edge = "───";
                cross1 = '┼';
                cross2 = '╫';
            }

            for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                stringBuilder.append(edge);

                if (i != LINE_UNIT_COUNT - 1) {
                    if (i % LINE_MATRIX_UNIT_COUNT == 2) {
                        stringBuilder.append(cross2);
                    } else {
                        stringBuilder.append(cross1);
                    }
                }
            }

            stringBuilder.append(System.lineSeparator());
        }

        private void printEx(boolean force) {
            if (!force && ++index % PRINT_STEP_COUNT != 0) {
                return;
            }

            System.out.println("this is the " + index + "'th loop result");
            System.out.println("empty:" + empty + ",finish:" + finish + ",effective:" + effective);

            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                for (int l = 0; l < MATRIX_LINT_UNIT_COUNT; ++l) {
                    for (int j = 0; j < LINE_UNIT_COUNT; ++j) {
                        for (int k = 0; k < MATRIX_LINT_UNIT_COUNT; ++k) {
                            int n = l * MATRIX_LINT_UNIT_COUNT + k + 1;

                            if (matrixEx[i][j].contains(n)) {
                                stringBuilder.append(" ").append(n).append(" ");
                            } else {
                                stringBuilder.append("   ");
                            }

                        }
                        if (j != LINE_UNIT_COUNT - 1) {
                            if (j % 3 == 2) {
                                stringBuilder.append('║');
                            } else {
                                stringBuilder.append('│');
                            }
                        }
                    }
                    stringBuilder.append(System.lineSeparator());
                }

                if (i != LINE_UNIT_COUNT - 1) {
                    boolean isDouble = i % 3 == 2;
                    printRowLineEx(isDouble, stringBuilder);
                }
            }
            stringBuilder.append(System.lineSeparator());
            System.out.println(stringBuilder);
        }

        private void printRowLineEx(boolean isDouble, StringBuilder stringBuilder) {
            String edge;
            char cross1;
            char cross2;
            if (isDouble) {
                edge = "═══";
                cross1 = '╪';
                cross2 = '╬';
            } else {
                edge = "───";
                cross1 = '┼';
                cross2 = '╫';
            }

            for (int j = 0; j < LINE_UNIT_COUNT; ++j) {
                for (int k = 0; k < LINE_MATRIX_UNIT_COUNT; ++k) {
                    stringBuilder.append(edge);
                }
                if (j != LINE_UNIT_COUNT - 1) {
                    if (j % LINE_MATRIX_UNIT_COUNT == 2) {
                        stringBuilder.append(cross2);
                    } else {
                        stringBuilder.append(cross1);
                    }
                }
            }

            stringBuilder.append(System.lineSeparator());
        }

        private void finish() {
            print("sudoku has find one answer showed followed so will exit normally");
            long endTime = System.currentTimeMillis();
            System.out.println("sudoku costs " + (endTime - startTime) + "ms to analyze this problem");
            System.exit(0);
        }

        public static class UnitToGuess {
            private int rowIndex;
            private int colIndex;

            private ArrayList<Integer> ones = new ArrayList<>();

            public int getRowIndex() {
                return rowIndex;
            }

            public int getColIndex() {
                return colIndex;
            }

            public ArrayList<Integer> getOnes() {
                return ones;
            }

            public UnitToGuess(int rowIndex, int colIndex, ArrayList<Integer> ones) {
                this.rowIndex = rowIndex;
                this.colIndex = colIndex;
                for (Integer e : ones) {
                    this.ones.add(e);
                }
            }

        }

        private boolean setOneUnit(int rowIndex, int colIndex, int element) {
            System.out.println("try to set unit[" + rowIndex + "," + colIndex + "]=" + element + " for next loop");
            return setUnit(false, rowIndex, colIndex, element);
        }

        public UnitToGuess fetchOneUnitToGuess() {
            int miniSize = MATRIX_UNIT_COUNT;
            int rowIndex = -1;
            int colIndex = -1;

            for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                for (int j = 0; j < LINE_UNIT_COUNT; ++j) {
                    if (matrixEx[i][j].size() > 1 && matrixEx[i][j].size() < miniSize) {
                        rowIndex = i;
                        colIndex = j;
                        miniSize = matrixEx[i][j].size();
                    }
                }
            }

            if (rowIndex != -1 && colIndex != -1) {
                return new UnitToGuess(rowIndex, colIndex, matrixEx[rowIndex][colIndex]);
            }

            return null;
        }

        public boolean setUnitLoop() {
            while (true) {
                int lastEffective = effective;
                if (!setUnitOfOneSize() || !setUnitInBlock() || !setUnitInLine(true) || !setUnitInLine(false)) {
                    printEx(true);
                    return false;
                }

                if (empty == 0) {
                    finish();
                }

                if (effective == lastEffective) {
                    System.out.println("this removeLoop can't remove any more");
                    break;
                }
            }

            return true;
        }

        private ArrayList<Integer> getUnit(boolean revert, int rowIndex, int colIndex) {
            return revert ? matrixEx[colIndex][rowIndex] : matrixEx[rowIndex][colIndex];
        }

        private boolean checkRight() {
            boolean flag = true;
            for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                for (int j = 0; j < LINE_UNIT_COUNT; ++j) {
                    if (matrix[i][j] != 0) {
                        for (int ii = i / LINE_MATRIX_UNIT_COUNT * LINE_MATRIX_UNIT_COUNT;
                             ii < i / LINE_MATRIX_UNIT_COUNT * LINE_MATRIX_UNIT_COUNT + LINE_MATRIX_UNIT_COUNT; ++ii) {
                            for (int jj = j / LINE_MATRIX_UNIT_COUNT * LINE_MATRIX_UNIT_COUNT;
                                 jj < j / LINE_MATRIX_UNIT_COUNT * LINE_MATRIX_UNIT_COUNT + LINE_MATRIX_UNIT_COUNT; ++jj) {
                                if ((i != ii || j != jj) && matrix[i][j] == matrix[ii][jj]) {
                                    System.out.println("[" + i + ',' + j + "]=[" + ii + ',' + jj + "]=" + matrix[i][j]);
                                    flag = false;
                                }
                            }
                        }

                        for (int k = 0; k < LINE_UNIT_COUNT; ++k) {
                            if (i != k && matrix[i][j] == matrix[k][j]) {
                                System.out.println("[" + i + ',' + j + "]=[" + k + ',' + j + "]=" + matrix[i][j]);
                                flag = false;
                            }
                            if (j != k && matrix[i][j] == matrix[i][k]) {
                                System.out.println("[" + i + ',' + j + "]=[" + i + ',' + k + "]=" + matrix[i][j]);
                                flag = false;
                            }
                        }
                    }
                }
            }

            if (!flag) {
                System.out.println("sudoku's first guess is error and will try the other guess again");
                printEx(true);
            }

            return flag;
        }

        private boolean setUnit(boolean revert, int rowIndex, int colIndex, Integer e) {
            int i;
            int j;
            if (revert) {
                i = colIndex;
                j = rowIndex;
            } else {
                i = rowIndex;
                j = colIndex;
            }

            if (matrix[i][j] == 0 && matrixEx[i][j].contains(e)) {
                matrixEx[i][j].clear();
                matrixEx[i][j].add(e);

                matrix[i][j] = e;
                matrixRow[i].add(e);
                matrixCol[j].add(e);
                matrixBlocks[i / LINE_MATRIX_UNIT_COUNT][j / LINE_MATRIX_UNIT_COUNT].add(e);

                --empty;
                ++finish;
                ++effective;

                printEx(false);
                return checkRight();
            }

            return true;
        }

        private boolean setUnitInLine(boolean isRow) {
            boolean revert = !isRow;

            for (int j = 0; j < LINE_UNIT_COUNT; ++j) {
                int[] count = new int[LINE_UNIT_COUNT + 1];
                for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                    for (int e : getUnit(revert, i, j)) {
                        count[e]++;
                    }
                }

                ArrayList<Integer> ones = new ArrayList<>();
                for (int k = 1; k <= MATRIX_UNIT_COUNT; ++k) {
                    if (count[k] == 1) {
                        ones.add(k);
                    }
                }

                for (int e : ones) {
                    for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                        boolean flag = setUnit(revert, i, j, e);
                        if (!flag) {
                            return false;
                        }
                    }
                }
            }

            return true;
        }

        private boolean setUnitInBlock() {
            for (int i = 0; i < LINE_MATRIX_COUNT; ++i) {
                for (int j = 0; j < LINE_MATRIX_COUNT; ++j) {
                    int[] count = new int[MATRIX_UNIT_COUNT + 1];
                    for (int ii = 0; ii < LINE_MATRIX_UNIT_COUNT; ++ii) {
                        for (int jj = 0; jj < LINE_MATRIX_UNIT_COUNT; ++jj) {
                            int indexI = i * LINE_MATRIX_UNIT_COUNT + ii;
                            int indexJ = j * LINE_MATRIX_UNIT_COUNT + jj;
                            for (int e : matrixEx[indexI][indexJ]) {
                                count[e]++;
                            }
                        }
                    }
                    ArrayList<Integer> ones = new ArrayList<>();
                    for (int k = 1; k <= MATRIX_UNIT_COUNT; ++k) {
                        if (count[k] == 1) {
                            ones.add(k);
                        }
                    }

                    for (int e : ones) {
                        for (int ii = 0; ii < LINE_MATRIX_UNIT_COUNT; ++ii) {
                            for (int jj = 0; jj < LINE_MATRIX_UNIT_COUNT; ++jj) {
                                int indexI = i * LINE_MATRIX_UNIT_COUNT + ii;
                                int indexJ = j * LINE_MATRIX_UNIT_COUNT + jj;
                                boolean flag = setUnit(false, indexI, indexJ, e);
                                if (!flag) {
                                    return false;
                                }
                            }
                        }
                    }
                }
            }
            return true;
        }

        private boolean setUnitOfOneSize() {
            for (int i = 0; i < LINE_UNIT_COUNT; ++i) {
                for (int j = 0; j < LINE_UNIT_COUNT; ++j) {
                    if (matrix[i][j] == 0) {
                        if (matrixEx[i][j].removeAll(matrixRow[i]) || matrixEx[i][j].removeAll(matrixCol[j])
                                || matrixEx[i][j].removeAll(matrixBlocks[i / LINE_MATRIX_UNIT_COUNT][j / LINE_MATRIX_UNIT_COUNT])) {
                            if (effective > 1000) {
                                System.out.println("may error occur");
                            }
                            ++effective;
                        }
                        if (matrixEx[i][j].size() == 0) {
                            return false;
                        } else if (matrixEx[i][j].size() == 1) {
                            boolean flag = setUnit(false, i, j, matrixEx[i][j].get(0));
                            if (!flag) {
                                return false;
                            }
                        }
                    }
                }
            }

            return true;
        }
    }


    public static void main(String[] args) {
        startTime = System.currentTimeMillis();
        String input =  "8,0,0,0,0,0,0,0,0\n" +
                        "0,0,3,6,0,0,0,0,0\n" +
                        "0,7,0,0,9,0,2,0,0\n" +
                        "0,5,0,0,0,7,0,0,0\n" +
                        "0,0,0,0,4,5,7,0,0\n" +
                        "0,0,0,1,0,0,0,3,0\n" +
                        "0,0,1,0,0,0,0,6,8\n" +
                        "0,0,8,5,0,0,0,1,0\n" +
                        "0,9,0,0,0,0,4,0,0";
//                "0,0,0,1,0,2,0,0,0\n" +
//                "0,0,8,0,6,0,7,0,5\n" +
//                "0,9,0,0,0,0,0,8,0\n" +
//                "4,0,0,0,1,0,0,0,0\n" +
//                "0,8,0,3,0,4,0,6,0\n" +
//                "3,0,0,0,2,0,8,0,0\n" +
//                "0,6,0,0,0,5,4,7,0\n" +
//                "0,0,5,0,7,0,6,0,9\n" +
//                "0,7,0,0,0,0,0,5,0";
//                        "0,0,0,0,0,2,0,5,0\n" +
//                        "0,7,8,0,0,0,3,0,0\n" +
//                        "0,0,0,0,0,4,0,0,0\n" +
//                        "5,0,0,0,0,0,0,0,0\n" +
//                        "0,0,0,0,0,0,1,0,0\n" +
//                        "0,0,0,0,3,0,7,0,8\n" +
//                        "2,0,0,0,0,0,0,4,0\n" +
//                        "0,0,0,0,0,5,0,9,0\n" +
//                        "0,1,0,0,7,0,0,0,0";
//                "0,0,0,0,0,0,7,0,0\n" +
//                "0,4,0,0,3,0,0,6,5\n" +
//                "0,0,1,0,0,8,0,0,0\n" +
//                "0,6,0,0,5,0,0,3,9\n" +
//                "4,0,0,6,0,0,0,0,0\n" +
//                "0,0,0,0,0,0,0,2,0\n" +
//                "8,0,0,0,0,3,0,9,7\n" +
//                "0,0,0,0,7,0,4,0,0\n" +
//                "0,9,0,0,0,0,2,0,0";
        solve(input);
    }
}

运行结果

... ...

this is the 2068'th loop result
empty:21,finish:60,effective:309
         │ 1       │    2    ║         │         │       3 ║         │         │         
         │         │         ║         │    5    │         ║       6 │ 4       │         
    8    │         │         ║ 7       │         │         ║         │         │       9 
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
         │         │       3 ║         │    2    │         ║ 1       │         │ 1       
         │ 4       │         ║       6 │         │         ║    5    │         │    5    
       9 │         │         ║         │         │    8    ║         │ 7       │         
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
         │         │         ║         │         │ 1       ║    2    │         │       3 
       6 │         │    5    ║ 4       │         │         ║         │         │         
         │ 7       │         ║         │       9 │         ║         │    8    │         
═════════╪═════════╪═════════╬═════════╪═════════╪═════════╬═════════╪═════════╪═════════
 1       │         │         ║    2  3 │       3 │         ║         │    2    │         
         │    5    │ 4     6 ║         │       6 │         ║         │         │ 4     6 
         │         │       9 ║         │    8    │ 7       ║    8    │       9 │         
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
         │       3 │         ║    2  3 │         │         ║         │    2    │ 1       
         │       6 │       6 ║         │ 4       │    5    ║         │         │       6 
         │    8    │       9 ║    8    │         │         ║ 7       │       9 │         
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
    2    │         │         ║ 1       │         │         ║         │       3 │         
         │       6 │ 4     6 ║         │       6 │         ║    5    │         │ 4  5  6 
         │    8    │ 7       ║         │    8    │       9 ║    8    │         │         
═════════╪═════════╪═════════╬═════════╪═════════╪═════════╬═════════╪═════════╪═════════
         │    2    │ 1       ║         │         │         ║       3 │         │         
    5    │         │         ║         │         │ 4       ║         │       6 │         
         │         │         ║       9 │ 7       │         ║         │         │    8    
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
         │       3 │         ║         │       3 │    2    ║         │ 1       │         
 4       │       6 │         ║    5    │       6 │         ║         │         │         
         │         │    8    ║         │         │         ║       9 │         │ 7       
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
       3 │         │         ║         │ 1       │         ║         │         │    2    
         │         │       6 ║         │         │       6 ║ 4       │    5    │         
         │       9 │ 7       ║    8    │         │         ║         │         │         


try to set unit[1,4]=8 for next loop
this is the 2069'th loop result
empty:29,finish:52,effective:291
         │ 1       │    2    ║         │         │       3 ║         │         │         
         │         │         ║         │    5    │         ║       6 │ 4       │         
    8    │         │         ║ 7       │         │         ║         │         │       9 
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
         │         │       3 ║         │         │    2    ║ 1       │         │ 1       
         │ 4       │         ║       6 │         │         ║    5    │         │    5    
       9 │         │         ║         │    8    │    8    ║         │ 7       │         
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
         │         │         ║         │         │ 1       ║    2    │         │       3 
       6 │         │    5    ║ 4       │         │         ║         │         │         
         │ 7       │         ║         │       9 │         ║         │    8    │         
═════════╪═════════╪═════════╬═════════╪═════════╪═════════╬═════════╪═════════╪═════════
 1  2  3 │         │         ║    2  3 │    2  3 │         ║ 1       │    2    │ 1       
         │    5    │ 4     6 ║         │       6 │         ║         │         │ 4     6 
         │         │       9 ║    8    │    8    │ 7       ║    8    │       9 │         
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
 1  2  3 │       3 │         ║    2  3 │         │         ║         │    2    │ 1       
         │       6 │       6 ║         │ 4       │    5    ║         │         │       6 
         │    8    │       9 ║    8    │         │         ║ 7       │       9 │         
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
    2    │         │         ║ 1       │    2    │         ║         │       3 │         
         │       6 │ 4     6 ║         │       6 │         ║    5    │         │ 4  5  6 
 7       │    8    │ 7       ║         │    8    │       9 ║    8    │         │         
═════════╪═════════╪═════════╬═════════╪═════════╪═════════╬═════════╪═════════╪═════════
         │    2    │ 1       ║         │         │         ║       3 │         │         
    5    │         │         ║         │         │ 4       ║         │       6 │         
         │         │         ║       9 │ 7       │         ║         │         │    8    
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
         │       3 │         ║         │    2  3 │    2    ║         │ 1       │         
 4       │       6 │         ║    5    │       6 │       6 ║         │         │         
         │         │    8    ║         │         │         ║       9 │         │ 7       
─────────┼─────────┼─────────╫─────────┼─────────┼─────────╫─────────┼─────────┼─────────
       3 │         │         ║       3 │ 1       │         ║         │         │    2    
         │         │       6 ║         │         │       6 ║ 4       │    5    │         
 7       │       9 │ 7       ║    8    │         │    8    ║         │         │         


sudoku has find one answer showed followed so will exit normally
empty:0,finish:81,effective:343
 8 │ 1 │ 2 ║ 7 │ 5 │ 3 ║ 6 │ 4 │ 9 
───┼───┼───╫───┼───┼───╫───┼───┼───
 9 │ 4 │ 3 ║ 6 │ 8 │ 2 ║ 1 │ 7 │ 5 
───┼───┼───╫───┼───┼───╫───┼───┼───
 6 │ 7 │ 5 ║ 4 │ 9 │ 1 ║ 2 │ 8 │ 3 
═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══
 1 │ 5 │ 4 ║ 2 │ 3 │ 7 ║ 8 │ 9 │ 6 
───┼───┼───╫───┼───┼───╫───┼───┼───
 3 │ 6 │ 9 ║ 8 │ 4 │ 5 ║ 7 │ 2 │ 1 
───┼───┼───╫───┼───┼───╫───┼───┼───
 2 │ 8 │ 7 ║ 1 │ 6 │ 9 ║ 5 │ 3 │ 4 
═══╪═══╪═══╬═══╪═══╪═══╬═══╪═══╪═══
 5 │ 2 │ 1 ║ 9 │ 7 │ 4 ║ 3 │ 6 │ 8 
───┼───┼───╫───┼───┼───╫───┼───┼───
 4 │ 3 │ 8 ║ 5 │ 2 │ 6 ║ 9 │ 1 │ 7 
───┼───┼───╫───┼───┼───╫───┼───┼───
 7 │ 9 │ 6 ║ 3 │ 1 │ 8 ║ 4 │ 5 │ 2 


sudoku costs 128ms to analyze this problem

进程已结束,退出代码0

答案

在这里插入图片描述

书中玉
关注
数独超难题目_号称世界上最难的一道数独题，你敢来挑战吗？据说答案只有一种...
weixin_39863161的博客
12-19 4180
大家好，欢迎来到“烧脑试炼营”，我是烧脑大师。秉承“休闲娱乐、提升智力”的宗旨，每天为大家分享一点烧脑难题，希望大家喜欢！说起一说，金庸老先生的武侠小说无疑是陪伴我们最久的，也是最受我们所喜爱的。金庸老先生的武侠作品陪伴着许许多多的80后、90后度过了童年时光。当金庸老先生与世长辞的消息一经爆出，许多忠实粉丝也是主动的将曾经的经典翻看了一遍。其中有这样一个故事：聪明的黄蓉会解数独吗？相传在《射雕英...
python解数独--世界最难数独2.3秒完成
热门推荐
littlethunder的专栏
08-04 6万+
“芬兰数学家因卡拉，花费3个月时间设计出了世界上迄今难度最大的数独游戏，而且它只有一个答案。因卡拉说只有思考能力最快、头脑最聪明的人才能破解这个游戏。”这是英国《每日邮报》2012年6月30日的一篇报道。看完这个新闻就对数独有点感兴趣了，于是用python解一下玩玩，无意中却戳穿了某个虚假新闻（下面有链接）。         上图就是那个最难数独。解数独用的就是深度优先搜索，有几个方面可
世界上最难的数独题
weixin_33896069的博客
03-26 1万+
难度等级：14518分，确实是超级难，一般的专家级的4000左右分就非常难了。 解题路径： 解完题后为： 转载于:https://www.cnblogs.com/webjlwang/p/10602720.html...
世界最难数独详细解题过程
01-23
世界最难数独详细解题过程！！！！讲解非常详细！！！！喜欢数独的朋友可以一起看看！！！！学习！
Python来处理数独游戏(含世界最难数独示例）
深度学习领域优质创作者，CSDN博客专家
03-01 1564
在一个9*9的九宫格里面推导出剩余的数字，要求每行、每列、每宫(3*3)的数字均包含1~9，且不重复！
java 解决世界最难数独
一只大黄鱼的博客
11-23 1561
使用java算法解决世界最难数独，当然其余的数独也同样适用，不过最多只能算出一个解，我这花费的时间是50ms，虽然我发现有些人可以做到40ms以内，可能是用c++写的，我这使用java给java学习者一个借鉴吧.
C++基于DPLL算法的SAT的蜂窝数独游戏求解程序,程序设计综合课程设计,包括SAT求解器板块、蜂窝数独转化成cnf公式板块
最新发布
04-24
综上所述，本项目不仅涉及了基本的编程语言C++，还涵盖了重要的算法DPLL，以及一种有趣的数学游戏——蜂窝数独。通过这个项目，开发者和学习者都能提升自己的算法思维和问题建模能力，同时对布尔逻辑和SAT求解有更...
华中科技大学程序设计综合课程设计任务设计问题-基于SAT的蜂窝数独游戏求解程序C++源码+文档说明+实验报告
04-24
2022级华中科技大学程序设计综合课程设计任务设计问题一——基于SAT的蜂窝数独游戏求解程序 软件架构 包括SAT求解器板块、蜂窝数独转化成cnf公式板块两个主要板块 几点建议 - 不懂运行，下载完可以私聊问，可远程...
C语言——搜索算法求解数独(DFS)
eeeee
04-09 1565
深度优先求解数独
数独——个人作品
05-30
计算机求解数独的算法有很多，比较典型的是回溯法，比较有名的是舞蹈链算法， 都是毫秒级解题。本程序采用舞蹈链算法，以DLL形式加载调用。 程序的界面基于.net完成，主要涉及数独盘面的优化显示，候选解的加深计算...
计算机解数独
12-15
通过算法解数组，并输出多组答案通过算法解数组，技术涉及数独、搜索、剪枝,、递归、回溯
数独问题流程图_算法实践——数独的基本解法
weixin_42206399的博客
12-28 1946
数独(Sudoku)是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。 每一道合格的数独谜题都有且仅有唯一答案，推理方法也以此为基础，任何无解或多解的题目都是不合格的。如下图所示，就是一个数独的题目关于数独的详细介绍，参看“百度百科——数独”数独的基本解法就是利用规则的摒弃法一些定义每一行...
Java解数独--世界最难数独
独自等待
08-07 2588
在其他地方看到这个方法，稍微修改了一下，贴出来 用到Shudu和Grid两个类, 运行 Shudu里的main方法， 我读取的是本地文件，据说这个是神马大师设计的最难数组，大家可以自行修改： package shudu; import java.io.*; import java.text.SimpleDateFormat; import java.util.*; pub
数独超难题目_一道超难的数独题
weixin_35411561的博客
12-29 4324
The numerical puzzle took Arto Inkala three months to design, and it has only one solution - one that only the sharpest minds will discover, he told the Daily Telegraph.A daily fixture of many newspap...
[20210425]什么？号称世界上最难的数独居然没有坚持到2秒
Yogurt_cry的博客
04-25 1175
0 前言 有一段时间，Yogurt 比较沉迷数独游戏，所以在手机上下了一个叫『数独Sudoku益智脑训练软件』的 App。从初级到困难玩了个遍，困难级和专业级的比较花时间，所以也不怎么玩。但是玩久了之后就有点厌倦了，总会想有什么办法可以让数独自动玩，我就轻松了(歪，人家是让你训练脑子的好不好)。 1 什么是数独(规则) 数独在百度百科上的介绍是这样的： 数独（shù dú）是源自18世纪瑞士的一种数学游戏。是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，
数独 两种难度
junerbaci的博客
06-27 662
数独一 9*9型的 不明白的可以私戳加我q或去acwing上给我留言提问 ac代码： ``` #include <stdio.h> #include <string.h> #include <algorithm> using namespace std; const int maxn=9; char str[100]; int row[maxn],co...
最难数独的快速解法 - python
weixin_34310369的博客
07-21 1415
转载于: www.jianshu.com/p/1b2ee6539… python3、numpy的学习 递归算法 世界最难数独 芬兰数学家因卡拉，花费3个月时间设计出了世界上迄今难度最大的数独游戏，而且它只有一个答案。因卡拉说只有思考能力最快、头脑最聪明的人才能破解这个游戏 数独解法 有很多，这里练习用排除+递归回溯法。 排除法很直观 根据已知的数字，排除同一行、同一列、同一九宫格内...
搜集的几个超高难度的数独题
shaowl111的专栏
06-11 2万+
本人搜集的几个超高难度的数独题，包含著名的芬兰数学字花了三个月制作的据说是世界上最难的题。但根据几个软件的难度评价，这个并不是最难的。欢迎大家给出高难度的数独题！ 题目 HoDoKu v2.2 难度评价 Sudoku Explainer v1.2.9 难度评价 000001007000060020800900300095400003003000400...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值