Java 求解数独问题的回溯算法

我一直在尝试实现一种回溯算法来解决java控制台应用程序中的数独问题。我以前从未实现过这个算法，可能只看几段youtube视频是不够的，因为它似乎没有像我认为的那样工作

我在黑板上手动填充了一个我在网上找到的真正的数独游戏。但是，它不会经过第一个广场。起初，我试图将整个东西嵌套在一个双for循环中，但这似乎也不起作用

我已经正确地测试了有效的移动方法，所以问题显然不存在。 谢谢你的帮助

public class Sudoku {

    public static int[][] createBoard(int n)
    {
        int[][] board = new int[n][n];
        for (int i=0; i<board.length; i++)
            for (int j=0; j<board[i].length; j++)
                board[i][j]=0;
        return board;
    }

    public static void printBoard(int[][] b)
    {
        int buffer=(int)Math.sqrt(b.length);
        String btm=new String(new char[buffer*buffer*3+buffer+1]).replace("\0", "_"); // fitting for all board size
        for (int i=0; i<b.length; i++)
        {
            if (i%buffer==0)
                System.out.println(btm);
            for (int j=0; j<b[i].length; j++)
            {
                if (j%buffer==0)
                    System.out.print("|");
                if (b[i][j]==0)
                    System.out.print(" _ ");
                else
                    System.out.print(" " + b[i][j] + " ");
            }
                System.out.println("|");
        }
        System.out.println(btm);
    }

    // returns true if a number can be inserted in a row. 
    public static boolean checkLegalRow(int[][] b, int row, int num)
    {
        for (int i=0; i<b.length; i++)
        {
            if (b[row][i]==num)
                return false;
        }
        return true;
    }
    // returns true if a number can be inserted in a column.
    public static boolean checkLegalCol(int[][] b, int col, int num)
    {
        for (int i=0; i<b.length; i++)
        {
            if (b[i][col]==num)
                return false;
        }
        return true;
    }

    //returns true if number can be inserted in its NxN box
    public static boolean checkLegalBox(int[][] b, int row, int col, int num)
    {
        int buffer=(int)Math.sqrt(b.length);
        for (int i=0, adjRow=row-(row%buffer); i<buffer; i++, adjRow++)
        {
            for (int j=0, adjCol=col-(col%buffer); j<buffer; j++, adjCol++)
            {
                if (b[adjRow][adjCol]==num)
                    return false;
            }
        }
        return true;
    }

    public static boolean legalMove(int[][] b, int row, int col, int num)
    {
        return checkLegalRow(b,row,num) && checkLegalCol(b,col,num) && checkLegalBox(b,row,col,num) && b[row][col]==0;
    }

    public static void solveBacktrack(int[][] b, int row, int col)
    {
        for (int k=1; k<=b.length; k++)
            {
                if (legalMove(b,row,col,k))
                {
                    b[row][col]=k;
                    if (row==b.length-1 && col==b.length-1)
                        printBoard(b);
                    else
                    {
                        //printBoard(b);
                        if (col==b.length-1)
                            solveBacktrack(b,row+1,0);
                        else
                            solveBacktrack(b,row,col+1);
                    }
                }
            }
    }

    public static void main(String[] args)
    {
        int[][] board=createBoard(9);
        board[0][1]=4; board[1][0]=6; board[2][1]=8; board[2][2]=9; board[0][3]=6; board[2][5]=3; board[1][7]=3;
        board[1][8]=1; board[3][3]=4;
        board[3][0]=2;  board[3][2]=1; board[3][4]=5; board[3][7]=7; board[3][8]=8; board[4][1]=5;
        board[4][3]=3; board[4][5]=7; board[5][0]=3; board[5][1]=6; board[5][4]=2; board[5][5]=8; board[5][8]=5;
        board[6][3]=1; board[6][6]=6; board[6][7]=4; board[7][0]=4; board[7][1]=3; board[7][8]=9; board[8][2]=6; 
        board[8][5]=9;
        printBoard(board);
        solveBacktrack(board,0,0);
    }
}

公共级数独{
公共静态int[]createBoard（int n）
{
int[][]板=新int[n][n]；
对于（int i=0；i您的检查方法是错误的：您没有检查单元格是否被注释中提到的@stark占用

下面是对checkLegalMove的更正：

public static boolean checkLegalMove(int[][] b, int row, int col, int num) {
  if (b[row][col] != 0) // occupied
    return false;
  // check row
  for (int i = 0; i < b[row].length; i++) {
    if (b[row][i] == num)
      return false;
  }
  // check column
  for (int i = 0; i < b.length; i++) {
    if (b[i][col] == num)
      return false;
  }
  // check box with some integer math
  for (int i = row / 3 * 3; i < (row / 3 + 1) * 3; i++) {
    if (i == row) // row already checked
      continue;
    for (int j = col / 3 * 3; j < (col / 3 + 1) * 3; j++) {
      if (j == col) // column already checked
        continue;
      if (b[i][j] == num)
        return false;
    }
  }
  return true;
}

最后是递归函数：

private static void solveBacktrack(int[][] b, int row, int col) {
  for (int k = 1; k <= b.length; k++) {
    if (checkLegalMove(b, row, col, k)) {
      b[row][col] = k;
      // find next free space
      int nextRow = row, nextCol = col;
      while(nextRow < b.length && b[nextRow][nextCol] != 0) {
        if (nextCol + 1 == b[nextRow].length) {
          nextCol = 0;
          nextRow++;
        } else {
          nextCol++;
        }
      }
      if (nextRow == b.length) {
        solved = true;
        break;
      }
      solveBacktrack(b, nextRow, nextCol);
      if (!solved)
        b[row][col] = 0; // reset if not solved
      else
        break;
    }
  }
}

private静态回溯（int[]b，int行，int列）{
对于（int k=1；k告诉我你们的逻辑。我认为你们只是通过迭代和检查那个数字是否已经存在来检查一个方框中数字的有效性，这是错误的。这样想。最初第一行、第一列和第一个块中并没有数字9。所以你们的逻辑说这个块应该有数字9。但可能有一个错误如果连第一行、第二列和第一个块都没有9。这是一个复杂的算法，需要大量计算。你需要跳舞链接：@Shubham Jain我不确定我是否在跟踪你。我正在检查这个数字是否可以显示，如果可以，我会去下一个方块检查。如果在某个阶段没有可能的选项，我会t将回溯并在原始循环中尝试另一个数字。至少这是我对这个概念的理解，基于一些youtube视频。在legalMove中，您需要测试正方形是否为0，否则您将覆盖已填充的正方形。
private static void solveBacktrack(int[][] b, int row, int col) {
  for (int k = 1; k <= b.length; k++) {
    if (checkLegalMove(b, row, col, k)) {
      b[row][col] = k;
      // find next free space
      int nextRow = row, nextCol = col;
      while(nextRow < b.length && b[nextRow][nextCol] != 0) {
        if (nextCol + 1 == b[nextRow].length) {
          nextCol = 0;
          nextRow++;
        } else {
          nextCol++;
        }
      }
      if (nextRow == b.length) {
        solved = true;
        break;
      }
      solveBacktrack(b, nextRow, nextCol);
      if (!solved)
        b[row][col] = 0; // reset if not solved
      else
        break;
    }
  }
}