回溯算法高效解标准数独(MarkDown)

数独的含义

根据9宫格盘面上的已知数字，推理出所有剩余空格的数字。
标准数独：使每个数字在每一行、每一列和每一宫中都仅出现一次。
异型数独：在满足标准数独的规则上，额外添加其他约束条件。

变量的定义

flag：二维数组，代表数独在初始状态中空白的区域
rule：三维数组，表示每种规则->每个位置->每个数值的占用情况
sudoku：二维数组，用于存储数独的数字分布状态

标准数独需三种规则， 如：每行->第几行->哪个数字=是否已占用(0未占用/1已占用)
异型数独可自行拓展， 如：对角线->第几条对角线->哪个数字=是否已占用(0未占用/1已占用)

算法思路

1. 读取数独的初始状态，填入sudoku变量
2. 在读取数独的初始状态的同时，初始化数字的可填区域，填入flag变量
3. 在读取数独的初始状态的同时，更新每种规则占用情况，填入rule变量
4. 从(0, 0)开始求解数独，进入首层递归
5. 遍历flag，获取下一个可填区域的位置
6. 若当前位置已超出期望，表明已得出数独的解，打印结果并回溯到上一层进行求解
7. 从指定数字开始，与当前位置的所有规则的交集进行对比，获取下一个可填数字
8. 修改当前位置的可填数，如果该数值为无效取值，则回溯到上一层进行求解
9. 更新每种规则的占用状态为已占用
10. 以当前的坐标作为实参进入下一层递归，返回步骤5
11. 更新每种规则的占用状态为未占用

数独样本

• 根据上图，转换为程序输入文本结构：

009008040
600000017
010040000
000000004
480603021
300000000
000090080
240000006
050700100

参考代码

#include <iostream>
#include <string>
#include <ctime>

using namespace std;

int rule[3][9][9], sudoku[9][9], flag[9][9];

int findSmallIndex(int rowIndex, int colIndex) {
  return (3 * (rowIndex / 3) + (colIndex / 3));
}

int findNextValue(int rowIndex, int colIndex, int start) {
  int index = findSmallIndex(rowIndex, colIndex);
  for (int i = start; i < 9; i++) {
    if (rule[0][rowIndex][i]) continue;
    if (rule[1][colIndex][i]) continue;
    if (rule[2][index][i]) continue;
    return i;
  }
  return -1;
}

void changeRule(int rowIndex, int colIndex, int style) {
  int index = findSmallIndex(rowIndex, colIndex);
  int value = sudoku[rowIndex][colIndex];
  rule[0][rowIndex][value] = style;
  rule[1][colIndex][value] = style;
  rule[2][index][value] = style;
}

void initSudoku() {
  for (int i = 0; i < 9; i++) {
    for (int j = 0; j < 9; j++) {
      sudoku[i][j] = getchar() - '0' - 1;
      flag[i][j] = sudoku[i][j] == -1 ? 1 : 0;
      if (!flag[i][j]) changeRule(i, j, 1);
    }
    getchar();
  }
}

void show() {
  string result;
  for (int i = 0; i < 81; i++) {
    result += to_string(sudoku[i / 9][i % 9] + 1);
    if (i % 9 == 8) result += "\n";
  }
  cout << result << endl;
}

void solve(int index) {
  int rowIndex, colIndex;
  while (index < 81) {
    rowIndex = index / 9;
    colIndex = index % 9;
    if (flag[rowIndex][colIndex] == 1) break;
    index++;
  }
  if (index == 81) {show(); return;}
  while (true) {
    sudoku[rowIndex][colIndex] = findNextValue(rowIndex, colIndex, sudoku[rowIndex][colIndex] + 1);
    if (sudoku[rowIndex][colIndex] != -1) {
      changeRule(rowIndex, colIndex, 1);
      solve(index + 1);
      changeRule(rowIndex, colIndex, 0);
    } else {
      break;
    }
  }
}

int main() {
  long time1, time2;
  initSudoku();
  time1 = clock();
  solve(0);
  time2 = clock();
  cout << "求解过程共用" << time2 - time1 << "毫秒" << endl;
  return 0;
}

算法评测

• 无冗余代码，无重复计算，代码可读性良好
• 可求解数独的所有解
• 对已知规则进行交集运算，快速得到下一个有效数字，缩减查询时间
• 求解速度快，数独初始状态全0的情况下，1秒可得40W组解
• 空间占用少，数独初始状态全0的情况下，CPU：25%，内存：360KB