回溯算法高效解标准数独

MarkDown版本

建议前往MarkDown版本进行查阅：点击链接，可读性更优，结构排版更好

数独的含义

根据9×9盘面上的已知数字，推理出所有剩余空格的数字，使每个数字在每一行、每一列和每一宫中都仅出现一次

变量的声明

• flag：一个二维数组，代表数独在初始状态中空白的区域
• rule：一个三维数组，标准数独只需三种规则（异形数独可自行拓展）：表示每种规则->每个位置->每个数值的占用情况。当值为0表示未占用，1表示已占用
• sudoku：一个二维数组，用于存储数独的数字分布状态

算法思路

1. 读取数独的初始状态，填入sudoku变量
2. 在读取数独的初始状态的同时，并初始化数字的可填区域，填入flag变量
3. 在读取数独的初始状态的同时，更新数独的数字占用情况，填入rule变量
4. 开始求解数独，进入首层递归
5. 获取下一个可填区域的位置
6. 若当前位置已超出期望，表明已得出数独的解，打印结果并回溯到上一层进行求解
7. 查找当前位置的数字占用情况，对三条规则进行交集运算，得出下一个可填数。如果超出期望，回溯到上一层进行求解
8. 修改当前位置的可填数，并更新对应数字的占用状态为已占用
9. 以当前的坐标作为实参进入下一层递归，返回步骤5
10. 修改当前位置的可填数，并更新对应数字的占用状态为未占用

数独样本

转换为输入文本为以下内容：注意，数字之间无空格，行与行之间不存在空行

009008040
600000017
010040000
000000004
480603021
300000000
000090080
240000006
050700100

参考代码

#include <iostream>
#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] ? 0 : 1;
            if (!flag[i][j]) changeRule(i, j, 1);
        }
        getchar();
    }
}

void show() {
    for (int i = 0; i < 9; i++) {
        string line = "";
        for (int j = 0; j < 9; j++) {
            line += '0' + sudoku[i][j] + 1;
        }
        cout << line << endl;
    }
}

void solve(int rowIndex, int colIndex) {
    if (colIndex == 9) {rowIndex++;colIndex = 0;}
    while (rowIndex <= 8 && !flag[rowIndex][colIndex]) {
        colIndex++;if (colIndex == 9) {rowIndex++;colIndex = 0;}
    }
    if (rowIndex > 8) {show();return;}
    while (~(sudoku[rowIndex][colIndex] = findNextValue(rowIndex, colIndex, sudoku[rowIndex][colIndex] + 1))) {
        changeRule(rowIndex, colIndex, 1);
        solve(rowIndex, colIndex + 1);
        changeRule(rowIndex, colIndex, 0);
    }
}

int main() {
    long time1, time2;
    initSudoku();
    time1 = clock();
    solve(0, 0);//从(0,0)位置开始填数
    time2 = clock();
    cout << "求解过程共用" << time2 - time1 << "毫秒" << endl;
    return 0;
}

算法评测

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