C++ - Sodoku Killer(DFS) - 实现一个数独解算器

以前挺喜欢玩数独的。

觉得这些组合之间有这么“巧合”的关系，真的很神奇。

既然现在要重温C++，那就用C++写个数独解算。

数独相关知识

什么是数独

什么是数独，详细可参考¹。

一个好的数独题，是只有一个解的，意思每个格子能填的数字最终是唯一的。

有一些没有设计好的数独题，会有多个解，也称无解。

解题技巧

数独技巧

我的数独解算器就参考了里面的部分直观法，与候选数法。

史上最难数独

在世界最难数独²

普通解法

数独技巧，之前说的这个都是普通解法。

DFS解法

除了普通解法，还有DFS数独解法，这种解法一般是用于计算机（非人类）的计算方法。

DFS了解：

• DFS数独解法³
• DFS(深度优先搜索算法)⁴ - 这篇是说明与代码都比较好
• 深度优先搜索⁵

因为DFS需要渗透数独的每个数字的分支结果。

试填数字的次数会非常非常大。

最糟糕时的时间复杂度为：O(!n)。

下面代码我是参考了：³，我将原文的代码中添加了更详细的注释：

这个版本的DFS算法，只要数独的数字位置合理的，就可以解算出来。
如果设计数独数字初始不足17个，解算来了会有不定个解，也就是我们说的数独无解，因为这并不数独。

// jave.lin - DFS解算数独
// 这个算法可以递归渗透9x9数独的所有分支，前提是每个已填的数字是合理的
// 參考：https://blog.csdn.net/qq_42837885/article/details/90085051
#include<stdio.h>
#include<stdlib.h>

// #define SHOW_PROC 	// 是否显示DFS处理过程

int max_deep = 0;
int rec_count = 0;
// 检测x,y格中，fillNum是否可填
bool check(int arr[9][9], int x, int y, int fillNum) {
	for (int i = 0; i < 9; i++) {	// 检测行、列
		if (arr[x][i] == fillNum || arr[i][y] == fillNum)
			return false;			// 不能填
	}

	#ifdef READABLE // 可读
	int maze[] = { 0,3,6 };			// 这个写法很简便，但是不利于阅读
	int boxRow = maze[x / 3];		// 检测宫格
	int boxCol = maze[y / 3];
	#else
	// 下面是比较高可读的写法：
	int boxRow = (x / 3) * 3;		// 检测宫格
	int boxCol = (y / 3) * 3;
	#endif

	for (int i = boxRow; i < boxRow + 3; i++) {
		for (int j = boxCol; j < boxCol + 3; j++) {
			if (arr[i][j] == fillNum)
				return false;		// 不能填
		}
	}
	return true;					// 能填
}
// 打印数独
void printSodoku(int arr[9][9]) {
    for (int i = 0; i < 9; i++) { //输出
        for (int j = 0; j < 9; j++) {
            printf("%d", arr[i][j]);
        }
        printf("\n");
    }
    printf("max_deep:%d\n", max_deep);
    printf("rec_count:%d\n", rec_count);
}
// depth first search，深度搜索
void dfs(int arr[9][9], int x, int y, int deep, bool &ret) {
	// 统计最大遍历深度
    max_deep = deep > max_deep ? deep : max_deep;
	// 统计递归次数
    ++rec_count;
	// 当遍历当第10行（即：索引为9的行）
	// 说明已经遍历完最后一行了
	if (x == 9) { //找到唯一最优解
        // printf("x==9\n");
		printSodoku(arr);
		ret = true;
		return;
	}
	// 如果没有填数字
	if (arr[x][y] == 0) {
		for (int i = 1; i <= 9; i++) { //遍历合法数字填空
			if (check(arr, x, y, i) == 1) { //判断是否合法
				arr[x][y] = i;//状态转移
				#ifdef SHOW_PROC
		        printSodoku();
                printf("fill:[%d][%d]=%d\n", x, y, i);
                system("pause");
				#endif
				// 下面的：	next x = x + (y + 1) / 9; 	// y的逢9进1作为x坐标
				// 			next y = (y + 1) % 9; 		// wrap在9之内作为y作为
				dfs(arr, x + (y + 1) / 9, (y + 1) % 9, deep + 1, ret); //递归下一个坐标点，即深搜
			}
			#ifdef SHOW_PROC
			else {
            	printf("can not fill:[%d][%d]=%d\n", x, y, i);
            }
			#endif
		}
		arr[x][y] = 0;//如果前面的递归都没有找到唯一的最优解，则回溯
		#ifdef SHOW_PROC
        printf("reset:[%d][%d]=%d\n", x, y, 0);
		#endif
	}
	else {
		#ifdef SHOW_PROC
        printf("[%d][%d]==%d, next to :[%d][%d]\n", x, y, arr[x][y], x + (y + 1) / 9, (y + 1) % 9);
		#endif
		dfs(arr, x + (y + 1) / 9, (y + 1) % 9, deep + 1, ret); //递归搜索下一个坐标点
	}
}

int main() {

	// 目前世界最难的数独题：
	// https://baike.baidu.com/item/%E4%B8%96%E7%95%8C%E6%9C%80%E9%9A%BE%E6%95%B0%E7%8B%AC
	int arr[9][9] = {   {0,0,5,3,0,0,0,0,0},
						{8,0,0,0,0,0,0,2,0},
						{0,7,0,0,1,0,5,0,0},
						{4,0,0,0,0,5,3,0,0},
						{0,1,0,0,7,0,0,0,6},
						{0,0,3,2,0,0,0,8,0},
						{0,6,0,5,0,0,0,0,9},
						{0,0,4,0,0,0,0,3,0},
						{0,0,0,0,0,9,7,0,0} };

	// 测试无解题
	// int arr[9][9] = {   { 0, 5, 2,      0, 0, 9,    0, 0, 0 },
	// 					{ 0, 0, 3,      0, 5, 0,    0, 1, 6 },
	// 					{ 0, 0, 4,      3, 0, 0,    0, 0, 5 },

	// 					{ 0, 6, 0,      0, 0, 3,    8, 0, 0 },
	// 					{ 0, 2, 0,      6, 9, 5,    0, 4, 0 },
	// 					{ 0, 0, 4,      2, 0, 0,    5, 6, 0 },

	// 					{ 0, 0, 7,      0, 0, 6,    3, 0, 0 },
	// 					{ 2, 3, 0,      0, 7, 0,    6, 0, 0 },
	// 					{ 0, 0, 0,      4, 3, 0,    0, 5, 0 },};
	// 传入数独数据
	// 从左上角0，0坐标格子开始DFS
	printSodoku(arr);
	printf(" === start dfs ===\n");
	bool ret = false;
	dfs(arr, 0, 0, 1, ret);
	if (ret) {
		printf("sodoku resolved!\n");
	} else {
		printf("sodoku invalidated!\n");
	}
	printf(" === end dfs ===\n");
	system("pause");
	return 0;
}

输出：

005300000
800000020
070010500
400005300
010070006
003200080
060500009
004000030
000009700
max_deep:0
rec_count:0
 === start dfs ===
145327698
839654127
672918543
496185372
218473956
753296481
367542819
984761235
521839764
max_deep:82
rec_count:14578
sodoku resolved!
 === end dfs ===

编写个数独解释器

数独数据：

// 骨灰级难度
int arr[9][9] = {
        //     { 0, 0, 0,      0, 0, 0,    0, 0, 0 },
        //      C1 C2 C3      C4 C5 C6    C7 C8 C9
        /*R1*/ { 0, 0, 0,      0, 5, 0,    0, 9, 0 },
        /*R2*/ { 0, 4, 2,      0, 0, 1,    7, 5, 0 },
        /*R3*/ { 0, 0, 0,      9, 0, 0,    6, 0, 3 },

        /*R4*/ { 0, 0, 7,      3, 0, 0,    0, 0, 4 },
        /*R5*/ { 0, 0, 9,      0, 0, 5,    0, 0, 0 },
        /*R6*/ { 0, 6, 0,      0, 2, 0,    0, 0, 0 },

        /*R7*/ { 0, 0, 0,      0, 0, 0,    2, 1, 9 },
        /*R8*/ { 0, 0, 0,      0, 0, 7,    0, 0, 0 },
        /*R9*/ { 0, 0, 8,      1, 0, 0,    3, 0, 0 },
    };

运行效果：

6 7 3 2 5 8 4 9 1
9 4 2 6 3 1 7 5 8
8 1 5 9 7 4 6 2 3
5 2 7 3 1 6 9 8 4
3 8 9 7 4 5 1 6 2
1 6 4 8 2 9 5 3 7
7 5 6 4 8 3 2 1 9
2 3 1 5 9 7 8 4 6
4 9 8 1 6 2 3 7 5

放上最难数独来测试

    // （目前普通解题不了，只能DFS）
     地狱级难度 - 世界最难数独：https://baike.baidu.com/item/%E4%B8%96%E7%95%8C%E6%9C%80%E9%9A%BE%E6%95%B0%E7%8B%AC
    // 注意：====>>>> 我这个数独程序解算不了（其实我这个程序没有回溯处理，意思，只要是需要试填的数独，我这个程序就可能解不了）
    // 只能使用DFS来解决
    // 这个数独设计者是：芬兰数学家因卡拉
    // 芬兰数学家因卡拉，花费3个月时间设计出了世界上迄今难度最大的数独游戏，而且它只有一个答案。
    // 因卡拉说只有思考能力最快、头脑最聪明的人才能破解这个游戏。这是英国《每日邮报》2012年6月30日的一篇报道。
    // 这个号称“世界最难数独”的“超级游戏”，却被扬州一位69岁的农民花三天时间解了出来，但是将第四行第二列的5改成了8。
    // 而这个具有初中文化的老汉，数独游戏启蒙正是源于扬子晚报。
    int arr[9][9] = {
        //     { 0, 0, 0,      0, 0, 0,    0, 0, 0 },
        //      C1 C2 C3      C4 C5 C6    C7 C8 C9
        /*R1*/ { 0, 0, 5,      3, 0, 0,    0, 0, 0 },
        /*R2*/ { 8, 0, 0,      0, 0, 0,    0, 2, 0 },
        /*R3*/ { 0, 7, 0,      0, 1, 0,    5, 0, 0 },

        /*R4*/ { 4, 0, 0,      0, 0, 5,    3, 0, 0 },
        /*R5*/ { 0, 1, 0,      0, 7, 0,    0, 0, 6 },
        /*R6*/ { 0, 0, 3,      2, 0, 0,    0, 8, 0 },

        /*R7*/ { 0, 6, 0,      5, 0, 0,    0, 0, 9 },
        /*R8*/ { 0, 0, 4,      0, 0, 0,    0, 3, 0 },
        /*R9*/ { 0, 0, 0,      0, 0, 9,    7, 0, 0 },
    };

运行效果

145327698
839654127
672918543
496185372
218473956
753296481
367542819
984761235
521839764
max_deep:81
rec_count:14577
sodoku resolved!

• max_deep 是DFS最大深度，刚好9*9=81，最大81次，刚好都递归过，这个数独难度真的大。
• rec_count 是递归的次数，用了14577 次递归。

GIF运行效果：

从上图，可以看到，我们先使用了自己的数独解算器，然后发现解算不了，就使用DFS来解算。

制作到游戏

以前我下载过手游数独，难度一般，最难的就专家级的。
以前玩的时候专家级大概就20~30分钟即可解决。

有4宫，6宫，9宫格的

4宫格的比较简单，基本都是7~9秒就可以解决。（适合小朋友入门）
6宫格的也是简单。（适合学会入门后进阶）
9宫格玩多了都觉得差不多。因为这个手游最大难度就专家级了。

后来我去网上找了一些骨灰级、至尊级，地狱级（就是我上面说的：史上最难数独，那题）。
真的很难，需要花很长时间，虽然可以算出来，但我就没必要玩那些了，需要助记工具太多才能完成。

其实制作好了简单的专家级9x9数独，基本就可以制作一款数独游戏了，还可以提供解题提示，与记录，方便回看解法。

然后在此基础上还可以制作畸形数独。
或是3D版数独。

Project

backup :

• Sodoku_vs_2019
• Sodoku_gplusplus_2019

编译环境

• VS2019 C++ 项目 F5即可。
• g++ 2019 项目
  • 编译常数：g++ .\Main.cpp .\PrintfCol.h .\Sodoku.cpp .\Sodoku.h .\Sodoku_Killer.cpp .\Sodoku_Killer.h -o Main
  • 运行：.\Main.exe

References

---

1. 百科数独 ↩︎

2. 世界最难数独 ↩︎

3. 数独游戏（dfs深搜） - 这个是比较简洁的 ↩︎ ↩︎

4. DFS(深度优先搜索算法) ↩︎

5. 深度优先搜索 ↩︎