在C中回溯数独求解器

Question

这是我被要求为一个班级做的一个程序，它必须解决一个大小为nxn的数独难题 使用回溯算法，但不需要检查子方形，只检查行和列。 我的程序的问题是回溯部分永远不会触发:(每当它到达无法继续它停止的点并打印板而不是擦除最后一次尝试并尝试别的东西。 抱歉没有评论，我现在只能访问代码（不在家），但它主要是非常简单的功能，问题出在aux_solveSudoku和sudoku函数中，这里是代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define UNASSIGNED 0

bool aux_SolveSudoku(int n, int array[][n]);
bool SolveSudoku(int n, int array[][n], int row, int col);
bool check(int n, int array[][n], int row, int col, int number);
bool CheckRow(int n, int array[][n], int row, int number);
bool CheckCol(int n, int array[][n], int col, int number);
bool CheckIfFull(int n, int array[][n]);
void printArray(int n, int array[][n]);

int main()
{
    int n;
    scanf(" %d", &n);
    int array[n][n];

    for(int i=0; i<n; i++){
        for(int j=0; j<n; j++){
            scanf(" %d",&array[i][j]);
        }
    }
    if (aux_SolveSudoku(n, array) == true)
          printArray(n, array);
    else
         printf("No Solution!");


  return 0;
}

bool aux_SolveSudoku(int n, int array[][n]){
    for (int row = 0; row < n; row++){
        for (int col = 0; col < n; col++){
            if (SolveSudoku(n, array, row, col) && CheckIfFull(n, array))
                return true;}
    }
    return false;
}

bool SolveSudoku(int n, int array[][n], int row, int col){
    if(array[row][col] != UNASSIGNED)
        return true;

    for(int i=1; i<=n; i++){
        if(check(n, array, row, col, i)){
            array[row][col] = i;

            if(SolveSudoku(n, array, row, col))
                return true;

            array[row][col] = UNASSIGNED;
        }
    }    
    return false;
}

bool check(int n, int array[][n], int row, int col, int number){
    return (!CheckRow(n, array, row, number) && !CheckCol(n, array, col, number));
} 

bool CheckRow(int n, int array[][n], int row, int number){
    for (int col = 0; col < n; col++){
        if (array[row][col] == number){
            return true;}
    }
    return false;
}

bool CheckCol(int n, int array[][n], int col, int number){
    for (int row = 0; row <  n; row++){
        if (array[row][col] == number){
            return true;}
    }
    return false;

}

bool CheckIfFull(int n, int array[][n]){
    for (int i = 0; i < n; i++){
            for (int j = 0; j < n; j++){
                if(array[i][j] == UNASSIGNED)
                    return false;
                    }
            }
    return true;
}

void printArray(int n, int array[][n]){
    for (int row = 0; row < n; row++){
            for (int col = 0; col < n; col++){
                printf("%d ", array[row][col]);}
            printf("\n");
        }
}

这是该程序的一组示例数据：

5
0 0 0 2 4
3 1 0 0 2
0 2 1 0 5
2 0 3 0 0
0 0 0 0 0

这显然有一个解决方案：

1 3 5 2 4
3 1 4 5 2
4 2 1 3 5
2 5 3 4 1
5 4 2 1 3

不幸的是，该程序找不到解决方案，但我不明白为什么不这样做。

Answer 1

由于代码的这一部分，回溯无效。

bool SolveSudoku(int n, int array[][n], int row, int col){
    if(array[row][col] != UNASSIGNED)
        return true;

    for(int i=1; i<=n; i++){
        if(check(n, array, row, col, i)){
            array[row][col] = i;

            if(SolveSudoku(n, array, row, col))
                return true;

            array[row][col] = UNASSIGNED;
        }
    }    
    return false;
}

具体来说，当check方法返回true时，array [row] [col]设置为i。

在下一个语句中，调用SolveSudoku，但是在row和col的相同值上。

由于此值未取消分配，SolveSudoku将返回true。由于它返回true，因此每个位置只尝试一个值。递归没有以正确的方式被利用。

我希望这能解释为什么代码中不会发生回溯。祝好运！如果您还有其他问题，请与我们联系......

这是我用Java编写的一个例子。在嵌套的for循环中不调用solve方法，因此以不同的方式评估某些结束条件。你只需用0,0调用这个方法就可以从那里调用....

void solve(int r, int c)
{
    if(board[r][c] == 0)
    {
        for(int i = 1; i < 10; i++)
        {
            if (!inRow(i, r) && !inCol(i, c) && !inSqr(i, r, c))
            {
                board[r][c] = i;
                if(r == 8 && c == 8)
                {
                    printBoard();
                    System.exit(0);
                }
                else if(c == 8) solve(r + 1, 0);
                else solve(r, c + 1);
            }
        }
        board[r][c] = 0;
    }
    else if(r == 8 && c == 8)
    {
        printBoard();
        System.exit(0);
    }
    else if(c == 8) 
    {
        solve(r + 1, 0);
    }
    else 
    {
        solve(r, c + 1);
    }
}

Answer 2

您需要提供一个错误处理的数独板的示例。我的（无可否认压力不大）测试显示它表现良好，但它似乎没有在SudokuSolver()中递归，这可能是你关注的要点。

3x3可解决

3
0 1 0
2 0 1
0 0 0

来自仪表程序的输出

-->> SolveSudoku (3x3) - r=0, c=0, level = 1:
0 1 0 
2 0 1 
0 0 0 
-->> SolveSudoku (3x3) - r=0, c=2, level = 1:
3 1 0 
2 0 1 
0 0 0 
-->> SolveSudoku (3x3) - r=1, c=1, level = 1:
3 1 2 
2 0 1 
0 0 0 
-->> SolveSudoku (3x3) - r=2, c=0, level = 1:
3 1 2 
2 3 1 
0 0 0 
-->> SolveSudoku (3x3) - r=2, c=1, level = 1:
3 1 2 
2 3 1 
1 0 0 
-->> SolveSudoku (3x3) - r=2, c=2, level = 1:
3 1 2 
2 3 1 
1 2 0 
Solution:
3 1 2 
2 3 1 
1 2 3 

4x4可解决

4
4 0 1 0
3 2 0 0
0 0 0 3
0 0 0 0

预期解决方案

4 3 1 2
3 2 4 1
1 4 2 3
2 1 3 4

来自仪表程序的输出

-->> SolveSudoku (4x4) - r=0, c=1, level = 1:
4 0 1 0 
3 2 0 0 
0 0 0 3 
0 0 0 0 
-->> SolveSudoku (4x4) - r=0, c=3, level = 1:
4 3 1 0 
3 2 0 0 
0 0 0 3 
0 0 0 0 
-->> SolveSudoku (4x4) - r=1, c=2, level = 1:
4 3 1 2 
3 2 0 0 
0 0 0 3 
0 0 0 0 
-->> SolveSudoku (4x4) - r=1, c=3, level = 1:
4 3 1 2 
3 2 4 0 
0 0 0 3 
0 0 0 0 
-->> SolveSudoku (4x4) - r=2, c=0, level = 1:
4 3 1 2 
3 2 4 1 
0 0 0 3 
0 0 0 0 
-->> SolveSudoku (4x4) - r=2, c=1, level = 1:
4 3 1 2 
3 2 4 1 
1 0 0 3 
0 0 0 0 
-->> SolveSudoku (4x4) - r=2, c=2, level = 1:
4 3 1 2 
3 2 4 1 
1 4 0 3 
0 0 0 0 
-->> SolveSudoku (4x4) - r=3, c=0, level = 1:
4 3 1 2 
3 2 4 1 
1 4 2 3 
0 0 0 0 
-->> SolveSudoku (4x4) - r=3, c=1, level = 1:
4 3 1 2 
3 2 4 1 
1 4 2 3 
2 0 0 0 
-->> SolveSudoku (4x4) - r=3, c=2, level = 1:
4 3 1 2 
3 2 4 1 
1 4 2 3 
2 1 0 0 
-->> SolveSudoku (4x4) - r=3, c=3, level = 1:
4 3 1 2 
3 2 4 1 
1 4 2 3 
2 1 3 0 
Solution:
4 3 1 2 
3 2 4 1 
1 4 2 3 
2 1 3 4 

4x4无法解决

4
4 0 1 0
3 2 0 0
0 0 0 2
0 0 0 0

这是无法解决的，因为在第一行没有任何地方放置2。

-->> SolveSudoku (4x4) - r=0, c=1, level = 1:
4 0 1 0 
3 2 0 0 
0 0 0 2 
0 0 0 0 
-->> SolveSudoku (4x4) - r=0, c=3, level = 1:
4 3 1 0 
3 2 0 0 
0 0 0 2 
0 0 0 0 
-->> SolveSudoku (4x4) - r=1, c=2, level = 1:
4 3 1 0 
3 2 0 0 
0 0 0 2 
0 0 0 0 
-->> SolveSudoku (4x4) - r=1, c=3, level = 1:
4 3 1 0 
3 2 4 0 
0 0 0 2 
0 0 0 0 
-->> SolveSudoku (4x4) - r=2, c=0, level = 1:
4 3 1 0 
3 2 4 1 
0 0 0 2 
0 0 0 0 
-->> SolveSudoku (4x4) - r=2, c=1, level = 1:
4 3 1 0 
3 2 4 1 
1 0 0 2 
0 0 0 0 
-->> SolveSudoku (4x4) - r=2, c=2, level = 1:
4 3 1 0 
3 2 4 1 
1 4 0 2 
0 0 0 0 
-->> SolveSudoku (4x4) - r=3, c=0, level = 1:
4 3 1 0 
3 2 4 1 
1 4 3 2 
0 0 0 0 
-->> SolveSudoku (4x4) - r=3, c=1, level = 1:
4 3 1 0 
3 2 4 1 
1 4 3 2 
2 0 0 0 
-->> SolveSudoku (4x4) - r=3, c=2, level = 1:
4 3 1 0 
3 2 4 1 
1 4 3 2 
2 1 0 0 
-->> SolveSudoku (4x4) - r=3, c=3, level = 1:
4 3 1 0 
3 2 4 1 
1 4 3 2 
2 1 0 0 
No Solution!

检测代码

#include <stdio.h>
#include <stdbool.h>

#define UNASSIGNED 0

bool aux_SolveSudoku(int n, int array[][n]);
bool SolveSudoku(int n, int array[][n], int row, int col);
bool check(int n, int array[][n], int row, int col, int number);
bool CheckRow(int n, int array[][n], int row, int number);
bool CheckCol(int n, int array[][n], int col, int number);
bool CheckIfFull(int n, int array[][n]);
void printArray(int n, int array[][n]);

int main(void)
{
    int n;
    scanf(" %d", &n);
    int array[n][n];

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
            scanf(" %d", &array[i][j]);
    }

    if (aux_SolveSudoku(n, array) == true)
    {
        printf("Solution:\n");
        printArray(n, array);
    }
    else
        printf("No Solution!\n");

    return 0;
}

bool aux_SolveSudoku(int n, int array[][n])
{
    for (int row = 0; row < n; row++)
    {
        for (int col = 0; col < n; col++)
        {
            if (SolveSudoku(n, array, row, col) && CheckIfFull(n, array))
                return true;
        }
    }
    return false;
}

bool SolveSudoku(int n, int array[][n], int row, int col)
{
    if (array[row][col] != UNASSIGNED)
        return true;
    static int level = 0;

    level++;
    printf("-->> SolveSudoku (%dx%d) - r=%d, c=%d, level = %d:\n", n, n, row, col, level);
    printArray(n, array);

    for (int i = 1; i <= n; i++)
    {
        if (check(n, array, row, col, i))
        {
            array[row][col] = i;

            if (SolveSudoku(n, array, row, col))
            {
                level--;
                return true;
            }

            array[row][col] = UNASSIGNED;
        }
    }
    level--;
    return false;
}

bool check(int n, int array[][n], int row, int col, int number)
{
    return(!CheckRow(n, array, row, number) && !CheckCol(n, array, col, number));
}

bool CheckRow(int n, int array[][n], int row, int number)
{
    for (int col = 0; col < n; col++)
    {
        if (array[row][col] == number)
        {
            return true;
        }
    }
    return false;
}

bool CheckCol(int n, int array[][n], int col, int number)
{
    for (int row = 0; row <  n; row++)
    {
        if (array[row][col] == number)
        {
            return true;
        }
    }
    return false;
}

bool CheckIfFull(int n, int array[][n])
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (array[i][j] == UNASSIGNED)
                return false;
        }
    }
    return true;
}

void printArray(int n, int array[][n])
{
    for (int row = 0; row < n; row++)
    {
        for (int col = 0; col < n; col++)
        {
            printf("%d ", array[row][col]);
        }
        printf("\n");
    }
}

变化基本上是微不足道的。你不需要<stdlib.h>;你需要在输出结束时换行。代码更加丰富地调用printArray()，并在找到解决方案时识别解决方案（避免将解决方案与跟踪混合在一起）。它保持一个级别计数器，当为未分配的方格输入函数时，该计数器会递增。

您没有验证输入（但可以并且可以说应该）;检测代码也不验证数据。

---

进一步观察

每次aux_SudokuSolver()调用SudokuSolver()时，都应尝试解决相同（尚未解决）的问题。但是，如果在输入函数时复制数组，然后在SudokuSolver()返回失败后将副本与原始数组进行比较，您会发现数组已更改，因此代码并不总是在解决一样的问题。你必须确保你总是试图在顶层解决同样的问题。