数独(sudoku)游戏的程序求解

9x9的正方形方格可以分成9个3×3的九宫格。

数独游戏是在这样的正方形中，首先事先给某些方格填入1-9的数字，然后要求在余下的方格中也填入1－9的数字，要求每一行，每一列，以及每个九宫格中，都正好包含1－9这九个数字。

解算 sudoku 的方法很多，前段时间闲的无聊我也写了一个。算法很简单，就是试填+递归穷举。方法有些暴力，不过很有效，程序也非常的简洁。

实际上，写完程序后我才发现，sudoku 的难点其实不在解算，而是如何生成数独题目，并且保证生成的题目解是唯一的。这个问题还要再思考思考，现在还没有什么思路。

下面是源程序，C语言写的，尽可能的使其保持 KISS （keep it simple and stupid）

sudoku 函数求出一个解。

sudoku_all 函数则试图穷举所有可行解。

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

#define SIZE 9

void display(char mat[SIZE][SIZE], char mes[]);
void copy(char src[SIZE][SIZE], char des[SIZE][SIZE]);
bool containInRow(char mat[SIZE][SIZE], int element, int row);
bool containInCol(char mat[SIZE][SIZE], int element, int col);
bool containInBlock(char mat[SIZE][SIZE], int element, int row, int col);
bool findFirstEmptyPos(char mat[SIZE][SIZE], int pos[2]);
void load(char mat[SIZE][SIZE]);
bool sudoku(char mat[SIZE][SIZE]);
bool sudoku_all(char mat[SIZE][SIZE]);

static int solution_count = 0;
static char message[] = "the number of possible solution is 9999999:";
int main(void)
{
    int i, j, t, ret;
 bool isOk;
    char mat[SIZE][SIZE];
 solution_count = 0;
    load(mat);

    display(mat, "origin matrix is ");
    isOk = sudoku_all(mat);
 if( isOk )
  display(mat, "solved matrix is ");
// else
//  puts("No valid solution");
  
 printf("the number of possible solution is %d:", solution_count);
// puts(message);
    return 0;
}

bool sudoku(char mat[SIZE][SIZE])
{
 char b[SIZE][SIZE];
 bool isOk;
 int pos[2], j;
 copy(mat, b);
 isOk = findFirstEmptyPos(b, pos); // 找到第一个需要填的位置
 if(isOk == false) return true; // 如果都填满了，返回 true. 表示成功的找到解了

 for(j = 1; j <= SIZE; j ++)
 {
  if( containInRow(b, j, pos[0]) ) continue;
  if( containInCol(b, j, pos[1]) ) continue;
  if( containInBlock(b, j, pos[0], pos[1]) ) continue;
  
  b[ pos[0] ][ pos[1] ] = j; // j 是一个可以填的值，试填之
  isOk = sudoku( b );
  if(isOk == true)
  {
   copy(b, mat); // 到这里了说明 j 填对了，并且后面的数也都填好了
   return true;  // 因此将结果拷贝到 mat 中。
  }
  copy(mat, b); // 到这里说明 j 填的不对，恢复 b ，重新填
 }
 return false; // 到这里了说明 1-9都试了全都不对，表明当前状态无解
}

bool sudoku_all(char mat[SIZE][SIZE]) //解出所有的可行解
{
 
 char b[SIZE][SIZE];
 bool isOk = false;
 int pos[2];
 copy(mat, b);
// display(mat, "inter");
 isOk = findFirstEmptyPos(b, pos); // 找到第一个需要填的位置
 if(isOk == false) 
 {
  solution_count ++;
  sprintf(message, "A possible solution (%d):", solution_count);
//  puts(message);
  display(mat, message);
  return false; //找到一组解后,仍然返回 false, 让程序继续找下一组解
 }

 for(int j = 1; j <= SIZE; j ++)
 {
  if( containInRow(b, j, pos[0]) ) continue;
  if( containInCol(b, j, pos[1]) ) continue;
  if( containInBlock(b, j, pos[0], pos[1]) )continue;
  b[ pos[0] ][ pos[1] ] = j; // j 是一个可以填的值，试填之
  isOk = sudoku_all( b ); // 无论找到解没有，都还原成原始状态，接着找下一组解
  copy(mat, b);  // 因为如果找到解了，解就已经用 display 函数输出了，接着找下一组解就可以了。
 }                  // 如果没找到解，同样也要恢复原始状态，试下一个可能的数
 return false; // 到这里了说明 1-9都试了全都不对，表明当前状态无解，返回到上一步，试下一个可能的数
}

void load(char mat[SIZE][SIZE])
{
    int i, j, t;
    for ( i = 0; i < SIZE; i++)
    {
        for (j = 0; j < SIZE ; j++)
        {
            scanf("%d", &t);
            mat[i][j] = t;
        }
    }
}
void display(char mat[SIZE][SIZE], char mes[])
{
    int i, j, t;
    puts(mes);
    for ( i = 0; i < SIZE; i++)
    {
        for (j = 0; j < SIZE ; j++)
        {
            t = mat[i][j];
            printf("%2d ", t);
        }
        puts("");
    }
}
/** 
 * @brief 判断一个数是否已经在这一行出现过了 
 */
bool containInRow(char mat[SIZE][SIZE], int element, int row)
{
    int i;
    for (i = 0; i < SIZE; i++)
    {
        if (mat[row][i] == element) return true;
    }
    return false;
}

/** 
 * @brief 判断一个数是否已经在这一列出现过了 
 */
bool containInCol(char mat[SIZE][SIZE], int element, int col)
{
    int i;
    for (i = 0; i < SIZE; i++)
    {
        if (mat[i][col] == element) return true;
    }
    return false;
}

/** 
 * @brief 判断一个数是否已经在这一3*3的小方块中出现过了 
 */
bool containInBlock(char mat[SIZE][SIZE], int element, int row, int col)
{
    int i = row / 3;
 int j = col / 3; 

    for (int ii = 0; ii < SIZE / 3; ii++)
    {
  for(int jj = 0; jj < SIZE / 3; jj++)
  {
   if (mat[i * 3 + ii][j * 3 + jj] == element) return true;
  }
    }
    return false;
}
void copy(char src[SIZE][SIZE], char des[SIZE][SIZE])
{
    int i, j;
    for (i = 0; i < SIZE; i++)
    {
        for (j = 0; j < SIZE; j++)
        {
            des[i][j] = src[i][j];
        }
    }
}

/** 
 * @brief 找到第一个需要填数字的位置
 * @para pos 通过 pos 返回位置坐标， pos[0] 为行号， pos[1] 为列号
 */
bool findFirstEmptyPos(char mat[SIZE][SIZE], int pos[2])
{
    int i, j;
    for (i = 0; i < SIZE; i++)
    {
        for (j = 0; j < SIZE; j++)
        {
            if (mat[i][j]  == 0)
            {

                pos[0] = i;
                pos[1] = j;
                return true;
            };
        }
    }
    return false;
}