Question

我正在尝试编写一个程序，它将使用回溯来创建一个Sudoku解算器。我已经能够创建一个黑色数独网格，我可以检查移动是否是一个有效的移动。我的程序工作正常，直到一个正方形有多个数字选择。

问题：你会看看我的Solve方法，看看我如何修改它以回溯，改变答案并再次前进。我给出了上述所有其他方法的名称以及其中的每一种方法。

示例输入：

int board[ROWS][COLS] = {
    { 6, 0, 3, 0, 2, 0, 0, 9, 0 },
    { 0, 0, 0, 0, 5, 0, 0, 8, 0 },
    { 0, 2, 0, 4, 0, 7, 0, 0, 1 },
    { 0, 0, 6, 0, 1, 4, 3, 0, 0 },
    { 0, 0, 0, 0, 8, 0, 0, 5, 6 },
    { 0, 4, 0, 6, 0, 3, 2, 0, 0 },
    { 8, 0, 0, 2, 0, 0, 0, 0, 7 },
    { 0, 1, 0, 0, 7, 5, 8, 0, 0 },
    { 0, 3, 0, 0, 0, 6, 1, 0, 5 }
};

bool sudokuBoard::emptyCell(int i, int j);

bool sudokuBoard::isValidCol(int i, int j, int number);

bool sudokuBoard::isValidRow(int i, int j, int number);

bool sudokuBoard::isValidSquare(int i, int j, int number);

bool sudokuBoard::validMove(int i, int j, int number);

void sudokuBoard::solvePuzzle(int row, int col) {

    for (int i = 1; i < 10; i++) {
        if (validMove(row, col, i)) {
            board[row][col] = i;
            showBoard();
        } 
    }
    if (row < 8 && col < 8) {
        if (col < 8) {
            solvePuzzle(row, col + 1);
        }
        else {
            col = 0;
            solvePuzzle(row + 1, col);
        }
    }
}

电流输出示例：

  6  5  3|  1  2  8|  4  9  0|
  0  0  0|  0  5  0|  0  8  0|
  0  2  0|  4  0  7|  0  0  1|
--------------------------------
  0  0  6|  0  1  4|  3  0  0|
  0  0  0|  0  8  0|  0  5  6|
  0  4  0|  6  0  3|  2  0  0|
--------------------------------
  8  0  0|  2  0  0|  0  0  7|
  0  1  0|  0  7  5|  8  0  0|
  0  3  0|  0  0  6|  1  0  5|

我的程序在第一行的最后0处停止，因为没有解决方案，除非之前的4更改为7，程序终止。

Answer 1

回溯可能很难在第一时间包裹你的思绪，所以我们将从一些关于你现在拥有的伪代码开始逐步采取这个步骤：

    while(puzzlenotsolved)
   {
    foreach row   
      {
         findEmptySquare
         {
         findValidMove(1-9)
         }
      }
   }

如果因为之前选择的值而无法找到正方形的有效移动，那么这当然会卡住。

为了解决这个问题，我们需要在广场中的有效移动用完时返回false，我们还需要取消分配我们的猜测以使方块再次为空。然后我们需要在我们离开的前一个广场继续循环。

所以我们找到有效的移动函数（在你的情况下解决难题）看起来像这样：

bool findValidMove
{
  if(noEmptySquare) {return true;}  //important bit

  findEmptySquare()
  for (1-9) 
       { if (isvalidMove )
            {
                assignMoveToSquare
            }
            if (findValidMove) {return true}  //important bit

         unassignMoveFromSquare   
       }
    return false; //no values valid in this square, a previous square has a wrong value
}

现在这被认为是一种蛮力方法，并且可以进行优化，但是对于您的问题，让我们回溯工作，如果您愿意，可以稍后担心速度优化。

请注意我评论的两个地方是重要位，第一个是没有空方块的能指。由于你的程序只分配有效的移动，因此这个难题应该是完整和正确的，所以程序返回true。这是基本情况，通常递归函数需要一个基本情况。

第二个重要的位是函数递归调用自身的位置。请注意，它仍在循环内，因此当调用返回false时，它将在之前的调用中恢复循环。除了我们的示例返回循环之外，每个调用都在this example中堆叠到另一个调用上。

请注意，在递归函数返回之前，单元格不会被取消分配，这使您不必担心在评论中提到的向行和列添加1。您所要做的就是拥有一个可靠的findEmptySquare方法，并且递归可以处理其余的事情。

您的showBoard();方法对于调试非常宝贵，我会说在assignMoveToSquare

之后把它放好

希望这有帮助，你真的很亲密，所以我认为它会。如果您有其他问题，请随时对此发表评论，我会尽量在有空的时候找到您。

Answer 2

这就是为我解决的问题。谢谢你的帮助。

bool sudokuBoard::solvePuzzle() {
    int row, col;

    if (emptyCell(row, col) == false) {
        return true; 
    }

    for (int i = 1; i < 10; i++) {
        cout << "Trying " << i << " in spot [" << row << "][" << col << "]" << endl;
        if (validMove(row, col, i)) {
            board[row][col] = i;
            showBoard();
            if (solvePuzzle()) {
                return true;
            }
            board[row][col] = 0;
        }
    }
    return false;
}

c ++中的递归回溯

2 个答案: