徐松亮算法教学-基于C语言的数独(九宫格)多种终盘生成方法（包含矩阵镜像旋转转置等相关算法）

最新推荐文章于 2022-09-04 21:06:01 发布
最新推荐文章于 2022-09-04 21:06:01 发布
阅读量1.3k 收藏 10
点赞数 3
分类专栏： 算法 C语言 文章标签： 数独 C语言 算法 矩阵 旋转
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xslxhn/article/details/83817909
版权

版权声明：本文为博主徐松亮的原创作品，未经允许不得转载，多谢支持！QQ：5387603

推荐点击此链接：欢迎进入徐松亮博客一站式导航搜索(随时更新)

 

目录

一,前言

二,开发环境

电脑系统

编译器

编程语言

编辑与工程环境

三,方法

方法概述

生成（或随机选定）种子矩阵终盘

两数交换法

非跨界行交换

非跨界列交换

块行交换

块列交换

矩阵旋转

矩阵行镜像

矩阵列镜像

矩阵对角线镜像

四,源码

五,运行结果演示

运行结果---两数交换法

运行结果---非跨界行交换

运行结果---非跨界列交换

运行结果---块行交换

运行结果---块列交换

运行结果---矩阵旋转

运行结果---矩阵行镜像

运行结果---矩阵列镜像

运行结果---矩阵对角线镜像

六,引用资料致谢

一,前言

  • 昨天,发布了一篇数独解题的文章，但是只有解题没有出题，总是感觉差点意思。
  • 网上搜了一些相关资料，大多都是单一方式，流程基本上是填入部分随机数---产生一个解盘---扣掉一些数。这个方案如果只是用于出题也是可行的，但是这么简单的话，我真是懒得总结。
  • 本文的矩阵转换算法都为博主亲自编写调试，都是自身转换，而不需要建立同样大小的缓存，尤其是矩阵旋转相关代码，还真花费了我一些时间，很是推荐，比目前网上的要好很多，后续我会把矩阵转换相关的代码标准化后另建立学习文档。
  • 偶然在网上发现一篇文章，它讲了多种数独终盘生成办法，主要是用的矩阵变换，还是那句话：虽然我对数独本身这个游戏没什么兴趣，但是对它涉及到的计算机数学问题，还是颇有兴趣。
  • 做到这，我想到一个问题，接数独是不是也可以用这篇文章讲的矩阵变换方法，经过各种行列兑换，生成一个解，原理有点像拧魔方似的，方法理论上应该是可行的，但不过这个方法不能统计出解的数量。

二,开发环境

三,方法

  • 方法概述

    • 基于一个成型的终盘，经过下列任意变换后，还是一个符合规则的终盘。

  • 生成（或随机选定）种子矩阵终盘

    • 如果能真正的随机生成一个终盘，那就不用下面的变换了，所以我们在此用选定的现有矩阵做种子。
    • 真正做可以多做几个，然后用随机数来选。

  • 两数交换法

    • 就是随机选取两个数，可以是1和9，也可以是3和5，全局交换后，仍是有效终盘。
    • 下图举例，我们已2和8来做交换，如图所示：

  • 非跨界行交换

    • 以宫为界，即1-3行为一组，4-6行为一组，7-9行为一组，组内可执行行交换，组间不能。符合此规则执行行交换后，终盘仍为符合规则的终盘。
    • 下图举例，同色为界，我们执行1与3行的数据交换。

  • 非跨界列交换

    • 以宫为界，即1-3列为一组，4-6列为一组，7-9列为一组，组内可执行行交换，组间不能。符合此规则执列列交换后，终盘仍为符合规则的终盘。
    • 下图举例，我们执列1与3列的数据交换。

  • 块行交换

    • 以宫为界，即1-3行为一组，4-6行为一组，7-9行为一组，组与组交换在此我起名称作块行交换。符合此规则交换后，终盘仍为符合规则的终盘。
    • 下图举例，我们组1与组2的数据交换。

  • 块列交换

    • 以宫为界，即1-3列为一组，4-6列为一组，7-9列为一组，组与组交换在此我起名称作块列交换。符合此规则交换后，终盘仍为符合规则的终盘。
    • 下图举例，我们组1与组2的数据交换。

  • 矩阵旋转

    • 矩阵旋转，就是相当于你转着圈的去看数独题，你从四个方向看，这个题都是成立的。
    • 下图举例，如图。

  • 矩阵行镜像

    • 矩阵行镜像，就好比你看完报纸正面，反过来看报纸背面一样。符合此规则交换后，终盘仍为符合规则的终盘。
    • 下图举例，如图

  • 矩阵列镜像

    • 矩阵列镜像，原理同行镜像其实是一样的。符合此规则交换后，终盘仍为符合规则的终盘。
    • 下图举例，如图

  • 矩阵对角线镜像

    • 矩阵对角线镜像，原理相当于数学当中的矩阵转置。
    • 下图举例，如图

四,源码

/**
  ******************************************************************************
  * @file    xsl_game_sudo.c
  * @author  徐松亮 许红宁(5387603@qq.com)
  * @version V1.0.0
  * @date    2018/11/01
  ******************************************************************************
  * @attention
  * 待解决
  * 1,数独出题
  * GNU General Public License (GPL)
  *
  * <h2><center>&copy; COPYRIGHT 2017 XSLXHN</center></h2>
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include <stdio.h>
#include <stdint.h>
// 用于计算耗时统计
#include <time.h>
/* Private define ------------------------------------------------------------*/
#define XSLGAMESUDO_SUDOKU_LEVEL 9
#define OK 0
#define ERR 1
/* Private typedef -----------------------------------------------------------*/
typedef struct
{
	// 输入---计算前用户设定
	uint8_t cells[XSLGAMESUDO_SUDOKU_LEVEL][XSLGAMESUDO_SUDOKU_LEVEL];
	//-----最大输出答案数量(1,为了防止pOutBuf数据溢出;2,为了计算适可而止;)
	uint32_t MaxOutAnswersCount;
	// 输入输出
	//-----输出缓存(NULL---无解输出)
	uint8_t *pOutBuf;
	//-----解最大数量(NULL---不求此值则非全局搜索)
	uint32_t *pAnswersCount;
	// 输出---计算后的统计结果
	uint32_t OutAnswersCount;
} XSLGAMESUDO_S_SUDO;
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
static const uint8_t XslGameSudo_SudoGenerateBuf[XSLGAMESUDO_SUDOKU_LEVEL][XSLGAMESUDO_SUDOKU_LEVEL] = {
	8, 1, 2, 7, 5, 3, 6, 4, 9,
	9, 4, 3, 6, 8, 2, 1, 7, 5,
	6, 7, 5, 4, 9, 1, 2, 8, 3,
	1, 5, 4, 2, 3, 7, 8, 9, 6,
	3, 6, 9, 8, 4, 5, 7, 2, 1,
	2, 8, 7, 1, 6, 9, 5, 3, 4,
	5, 2, 1, 9, 7, 4, 3, 6, 8,
	4, 3, 8, 5, 2, 6, 9, 1, 7,
	7, 9, 6, 3, 1, 8, 4, 5, 2};
//
XSLGAMESUDO_S_SUDO XslGameSudo_s_Sudo;
/* Extern variables ----------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/**
 * @brief   格式化打印
 * @note    打印指定行列的数组
 * @param   *pXslGameSudoS	---	数据指针
 * 			mode			---	0-打印问题	1-打印答案 2-只打印数独不打印字符串
 * @return  null
 */
static void XslGameSudo_FormatPrint(XSLGAMESUDO_S_SUDO *pXslGameSudoS, uint8_t mode)
{
	uint8_t i, j, k;
	uint8_t *pbuf;
	// 打印问题
	if ((mode == 0) || (mode == 2))
	{
		if (mode == 0)
		{
			printf("Sudo Questions:\n");
		}
		pbuf = (uint8_t *)pXslGameSudoS->cells;
		for (i = 0; i < XSLGAMESUDO_SUDOKU_LEVEL; i++)
		{
			for (j = 0; j < XSLGAMESUDO_SUDOKU_LEVEL; j++)
			{
				printf("%2d", pbuf[i * XSLGAMESUDO_SUDOKU_LEVEL + j]);
				if (j == (XSLGAMESUDO_SUDOKU_LEVEL - 1))
					printf("\n");
			}
		}
	}
	// 打印答案
	else if (mode == 1)
	{
		if (pXslGameSudoS->pAnswersCount == 0)
		{
			printf("Sudo Processor : No Solution!\n");
			return;
		}
		//
		pbuf = pXslGameSudoS->pOutBuf;
		for (k = 0; k < pXslGameSudoS->OutAnswersCount; k++)
		{
			printf("Sudo Answers(%d):\n", k + 1);
			for (i = 0; i < XSLGAMESUDO_SUDOKU_LEVEL; i++)
			{
				for (j = 0; j < XSLGAMESUDO_SUDOKU_LEVEL; j++)
				{
					printf("%2d", pbuf[(k * XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL) + (i * XSLGAMESUDO_SUDOKU_LEVEL + j)]);
					if (j == (XSLGAMESUDO_SUDOKU_LEVEL - 1))
						printf("\n");
				}
			}
		}
		if (pXslGameSudoS->pAnswersCount != NULL)
		{
			printf("Sudo Answers Count: %d\n", *(pXslGameSudoS->pAnswersCount));
		}
	}
}

uint8_t XslGameSudo_Generate(XSLGAMESUDO_S_SUDO *pXslGameSudoS)
{
	uint8_t num = 1;
	// 生成种子数独
	memcpy((uint8_t *)(pXslGameSudoS->cells), (uint8_t *)&XslGameSudo_SudoGenerateBuf[0][0], XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL);
	printf("%d,----------Seeds sudoku:\n", num++);
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	//----------
	memcpy((uint8_t *)(pXslGameSudoS->cells), (uint8_t *)&XslGameSudo_SudoGenerateBuf[0][0], XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL);
	// 两数交换法
	{
		uint8_t commutation_data_1, commutation_data_2;
		uint8_t i;
		uint8_t *pbuf = pXslGameSudoS->cells;
		// 设定交换数
		commutation_data_1 = 2;
		commutation_data_2 = 8;
		// 执行数据交换
		for (i = 0; i < XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL; i++)
		{
			if (pbuf[i] == commutation_data_1)
			{
				pbuf[i] = commutation_data_2;
			}
			else if (pbuf[i] == commutation_data_2)
			{
				pbuf[i] = commutation_data_1;
			}
			else
			{
				;
			}
		}
	}
	printf("Point Exchange method sudoku(point:2,8):\n");
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	//----------
	memcpy((uint8_t *)(pXslGameSudoS->cells), (uint8_t *)&XslGameSudo_SudoGenerateBuf[0][0], XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL);
	printf("%d,----------Seeds sudoku:\n", num++);
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	// 非跨界行交换
	{
		uint8_t commutation_row_1, commutation_row_2;
		uint8_t i, temp;
		// 设定交换行(0-8有效)
		commutation_row_1 = 0;
		commutation_row_2 = 2;
		// 执行交换行
		for (i = 0; i < XSLGAMESUDO_SUDOKU_LEVEL; i++)
		{
			temp = pXslGameSudoS->cells[commutation_row_1][i];
			pXslGameSudoS->cells[commutation_row_1][i] = pXslGameSudoS->cells[commutation_row_2][i];
			pXslGameSudoS->cells[commutation_row_2][i] = temp;
		}
	}
	printf("Row Exchange method sudoku(row:1,3):\n");
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	//----------
	memcpy((uint8_t *)(pXslGameSudoS->cells), (uint8_t *)&XslGameSudo_SudoGenerateBuf[0][0], XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL);
	printf("%d,----------Seeds sudoku:\n", num++);
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	// 非跨界列交换
	{
		uint8_t commutation_col_1, commutation_col_2;
		uint8_t i, temp;
		// 设定交换行(0-8有效)
		commutation_col_1 = 0;
		commutation_col_2 = 2;
		// 执行交换行
		for (i = 0; i < XSLGAMESUDO_SUDOKU_LEVEL; i++)
		{
			temp = pXslGameSudoS->cells[i][commutation_col_1];
			pXslGameSudoS->cells[i][commutation_col_1] = pXslGameSudoS->cells[i][commutation_col_2];
			pXslGameSudoS->cells[i][commutation_col_2] = temp;
		}
	}
	printf("Col Exchange method sudoku(col:1,3):\n");
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	//----------
	memcpy((uint8_t *)(pXslGameSudoS->cells), (uint8_t *)&XslGameSudo_SudoGenerateBuf[0][0], XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL);
	printf("%d,----------Seeds sudoku:\n", num++);
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	// 块行交换
	{
		uint8_t commutation_blockrow_1, commutation_blockrow_2;
		uint8_t i, j, temp;
		// 设定交换行(0-2有效)
		commutation_blockrow_1 = 0;
		commutation_blockrow_2 = 1;
		// 执行交换行
		for (i = 0; i < XSLGAMESUDO_SUDOKU_LEVEL; i++)
		{
			for (j = 0; j < 3; j++)
			{
				temp = pXslGameSudoS->cells[commutation_blockrow_1 * 3 + j][i];
				pXslGameSudoS->cells[commutation_blockrow_1 * 3 + j][i] = pXslGameSudoS->cells[commutation_blockrow_2 * 3 + j][i];
				pXslGameSudoS->cells[commutation_blockrow_2 * 3 + j][i] = temp;
			}
		}
	}
	printf("Block Row Exchange method sudoku(Block Row:1,2):\n");
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	//----------
	memcpy((uint8_t *)(pXslGameSudoS->cells), (uint8_t *)&XslGameSudo_SudoGenerateBuf[0][0], XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL);
	printf("%d,----------Seeds sudoku:\n", num++);
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	// 块列交换
	{
		uint8_t commutation_blockrow_1, commutation_blockrow_2;
		uint8_t i, j, temp;
		// 设定交换行(0-2有效)
		commutation_blockrow_1 = 0;
		commutation_blockrow_2 = 1;
		// 执行交换行
		for (i = 0; i < XSLGAMESUDO_SUDOKU_LEVEL; i++)
		{
			for (j = 0; j < 3; j++)
			{
				temp = pXslGameSudoS->cells[i][commutation_blockrow_1 * 3 + j];
				pXslGameSudoS->cells[i][commutation_blockrow_1 * 3 + j] = pXslGameSudoS->cells[i][commutation_blockrow_2 * 3 + j];
				pXslGameSudoS->cells[i][commutation_blockrow_2 * 3 + j] = temp;
			}
		}
	}
	printf("Block Col Exchange method sudoku(Block Col:1,2):\n");
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	//----------
	memcpy((uint8_t *)(pXslGameSudoS->cells), (uint8_t *)&XslGameSudo_SudoGenerateBuf[0][0], XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL);
	printf("%d,----------Seeds sudoku:\n", num++);
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	// 矩阵旋转(下面是方形矩阵的自旋转程序(不用额外缓存))
	{
		uint8_t i, j, k, n, x;
		uint8_t temp1, temp2;
		//设置参数
		n = XSLGAMESUDO_SUDOKU_LEVEL;
		x = n / 2;
		// 一圈一圈处理
		k = n - 1;
		for (i = 0; i < x; i++)
		{
			for (j = 0; j < k; j++)
			{
				//右列
				temp1 = pXslGameSudoS->cells[i + j][n - 1 - i];
				pXslGameSudoS->cells[i + j][n - 1 - i] = pXslGameSudoS->cells[i][i + j];
				//下行
				temp2 = pXslGameSudoS->cells[n - 1 - i][n - 1 - i - j];
				pXslGameSudoS->cells[n - 1 - i][n - 1 - i - j] = temp1;
				//左列
				temp1 = pXslGameSudoS->cells[n - 1 - i - j][i];
				pXslGameSudoS->cells[n - 1 - i - j][i] = temp2;
				//左上
				pXslGameSudoS->cells[i][i + j] = temp1;
			}
			k -= 2;
		}
	}
	printf("Rotate method sudoku(90 degrees):\n");
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	//----------
	memcpy((uint8_t *)(pXslGameSudoS->cells), (uint8_t *)&XslGameSudo_SudoGenerateBuf[0][0], XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL);
	printf("%d,----------Seeds sudoku:\n", num++);
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	// 矩阵行镜像
	{
		uint8_t i, j;
		uint8_t temp;
		//
		for (i = 0; i < XSLGAMESUDO_SUDOKU_LEVEL / 2; i++)
		{
			for (j = 0; j < XSLGAMESUDO_SUDOKU_LEVEL; j++)
			{
				temp = pXslGameSudoS->cells[j][XSLGAMESUDO_SUDOKU_LEVEL - 1 - i];
				pXslGameSudoS->cells[j][XSLGAMESUDO_SUDOKU_LEVEL - 1 - i] = pXslGameSudoS->cells[j][i];
				pXslGameSudoS->cells[j][i] = temp;
			}
		}
	}
	printf("X Mirror sudoku:\n");
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	//----------
	memcpy((uint8_t *)(pXslGameSudoS->cells), (uint8_t *)&XslGameSudo_SudoGenerateBuf[0][0], XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL);
	printf("%d,----------Seeds sudoku:\n", num++);
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	// 矩阵列镜像
	{
		uint8_t i, j;
		uint8_t temp;
		//
		for (i = 0; i < XSLGAMESUDO_SUDOKU_LEVEL / 2; i++)
		{
			for (j = 0; j < XSLGAMESUDO_SUDOKU_LEVEL; j++)
			{
				temp = pXslGameSudoS->cells[XSLGAMESUDO_SUDOKU_LEVEL - 1 - i][j];
				pXslGameSudoS->cells[XSLGAMESUDO_SUDOKU_LEVEL - 1 - i][j] = pXslGameSudoS->cells[i][j];
				pXslGameSudoS->cells[i][j] = temp;
			}
		}
	}
	printf("Y Mirror sudoku:\n");
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	//----------
	memcpy((uint8_t *)(pXslGameSudoS->cells), (uint8_t *)&XslGameSudo_SudoGenerateBuf[0][0], XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL);
	printf("%d,----------Seeds sudoku:\n", num++);
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	// 矩阵对角线镜像
	{
		uint8_t i, j;
		uint8_t temp;
		for (i = 0; i < XSLGAMESUDO_SUDOKU_LEVEL - 1; i++)
		{
			for (j = 0; j < XSLGAMESUDO_SUDOKU_LEVEL - 1 - i; j++)
			{
				temp = pXslGameSudoS->cells[i + j + 1][i];
				pXslGameSudoS->cells[i + j + 1][i] = pXslGameSudoS->cells[i][i + j + 1];
				pXslGameSudoS->cells[i][i + j + 1] = temp;
			}
		}
	}
	printf("Transpose sudoku:\n");
	XslGameSudo_FormatPrint(pXslGameSudoS, 2);
	//----------
}
/**
 * @brief   main函数
 * @note    主函数入口
 * @param   null
 * @return  null
 */
uint8_t MemBuf[1024]; //81个字节存储一组解,1024可以存储大于10个解
uint32_t SudoCount;
void main(int argc, char **argv)
{
	uint8_t res;
	uint32_t time1, time2;
	printf("--------------------------------------------------\n");
	printf("             XSL Sudo Generate(Normal)            \n");
	printf("--------------------------------------------------\n");
	XslGameSudo_Generate(&XslGameSudo_s_Sudo);
while(1);
	printf("--------------------------------------------------\n");
	printf("             XSL Sudo Processor(Normal)           \n");
	printf("--------------------------------------------------\n");
	// 数据载入
	memcpy((uint8_t *)(XslGameSudo_s_Sudo.cells), (uint8_t *)&XslGameSudo_SudoBuf[0][0], XSLGAMESUDO_SUDOKU_LEVEL * XSLGAMESUDO_SUDOKU_LEVEL);
	// 设置配置
	//---最多解析10个解
	XslGameSudo_s_Sudo.MaxOutAnswersCount = 5;
	XslGameSudo_s_Sudo.pOutBuf = MemBuf;
	XslGameSudo_s_Sudo.pAnswersCount = &SudoCount;
	// 打印原始数独
	XslGameSudo_FormatPrint(&XslGameSudo_s_Sudo, 0);
	// 启动数独测试
	time1 = GetTickCount();
	XslGameSudo_Processor(&XslGameSudo_s_Sudo);
	time2 = GetTickCount();
	// 打印结果
	XslGameSudo_FormatPrint(&XslGameSudo_s_Sudo, 1);
	// 打印耗时
	printf("Time(ms):%ld\n", time2 - time1);
	// 定住页面,否则程序结束直接闪退,延时10秒自动退出
	time1 = time2 = 0;
	time1 = GetTickCount();
	while (((time2 - time1) < 100000) || (time2 == 0))
	{
		time2 = GetTickCount();
	}
}

五,运行结果演示

  • 运行结果---两数交换法

  • 运行结果---非跨界行交换

  • 运行结果---非跨界列交换

  • 运行结果---块行交换

  • 运行结果---块列交换

  • 运行结果---矩阵旋转

  • 运行结果---矩阵行镜像

  • 运行结果---矩阵列镜像

  • 运行结果---矩阵对角线镜像

六,引用资料致谢

徐松亮
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数独游戏算法（C实现）
09-21
使用C语言展示数独游戏的算法，对于学习C语言和了解数独算法都有帮助
用 Python 编程解数独的思路和源码（LeetCode Problem 37）
许张弛
08-22 1310
最近做了LeetCode上关于数独的题目，下面将问题描述、解题思路和源码分享如下，希望网友们批评指正： 问题描述 编写程序通过填写空白单元格来解数独。 一个数独的解需要满足下列条件： 数字1-9每行每个数字只能出现一次。 数字1-9每列每个数字只能出现一次。 数字1-9在9个3×3的小方格里每个数字只能出现一次。 空白的单元格用字符“.”表示。 一个数独问题示例 它的解法用红色...
关于解数独程序的设计思想与方案
nsdcomputer的专栏
06-26 7803
       程序说明， 这个程序是由玩数独游戏而产生的，目的是同过设计这样一个程序提高自己的程序设计水平，提高对计算机应用的认识，同时来增强游戏的可玩性； 程序设计中用到了很多我在玩数独时的经验； 一、数独题目（困难级）：http://www.sudoku.name/       解题要求： http://www.sudoku.name/rules/cn， 用数字 1~9
用C语言解9×9数独 （亲测可用）（思路分析）
鱼_丸 的 博客
02-13 3773
用C语言解9×9数独 （亲测可用）（思路分析） 用的方法是基本的解数独思路，即按每一行每一列以及所在的九宫格，数字不重复的原则依次进行检索。
37.解数独(内含回溯算法重要思路)
weixin_50437588的博客
09-04 389
编写一个程序，通过填充空格来解决数独问题。数独的解法需 遵循如下规则：数字 1-9 在每一行只能出现一次。数字 1-9 在每一列只能出现一次。数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）数独部分空格内已填入了数字，空白格用 '.' 表示。
九宫格数独题目生成器.rar
04-16
《九宫格数独题目生成器》是一款基于C#编程语言开发的应用程序，主要用于自动生成数独题目。这款工具在原有基础上进行了优化，加入了多线程处理功能，从而提升了生成题目的效率，使得用户能够快速获取到难度各异的...
数独九宫格，excel自动生成版
最新发布
07-08
下载excel后，打开下方的sheet1，即为九宫格题目，复制到word内打印即可。 详细说明： 1.更改sheet2内的A1单元格内的数字（范围1-9），可以调节数独的难度，1难度最低，9难度最高，建议设置为5以下。 2.sheet2内为...
数独游戏终盘生成算法1
08-08
数独游戏终盘生成算法是计算机科学中一种有趣的算法应用，主要目的是生成具有唯一解决方案的数独谜题。本文将探讨四种不同的数独终盘生成方法，并以代码示例展示其中的一种。 首先，数独是一种逻辑游戏，由9x9的...
微信小程序实现九宫格数独
08-03
数独是一种基于逻辑的数字填充游戏，通常在9x9的九宫格中进行，分为9个3x3的小九宫格。每个小九宫格、每一行和每一列都必须填入数字1至9，且每个数字不能重复。游戏开始时，一部分格子会预先给出数字，玩家的任务是...
九宫格数独100题及答案（初级可打印版）
04-23
九宫格数独100题及答案（初级可打印版）
数独C语言实现
05-12
数独游戏实现代码，功能比较齐全，保存载入等等，界面美观
随机数独终盘，数独初盘的生成思路
w472822041的博客
08-30 956
随机数独终盘，数独初盘的生成思路
数独的编程求解
weixin_43747857的博客
03-19 1546
@(这里写自定义目录标题) 数独的编程求解 求解过程是用候选数求解法，用编程实现了唯一数求解、区块删除法和对数法。其它实现方法待实现后再写。 数据准备 用一个9*9的二维数组存储九宫格内数据，而每一个格子的数据用一个二进制表示。这里我采用了10位二进制，最低位作为候选数和已解数的标志，1标志其为候选数，0为已解数。其它9位表示1-9。例如1000000000表示已解数9，1100000001表...
数独游戏编程另一种思路
weixin_30633949的博客
09-23 177
最近在北京青年报偶然看到了一个数独游戏的题，具体来说就是按规矩进行填书。自己想了想，觉得还是有点费脑子的。于是就编写了一个程序，可以搜索数独游戏的所有答案。算法很简单，就是使用了回溯+剪枝，效率可能不是很高。不过对于9*9规模不是很大的问题，也应该足够了，不知道大家有什么好的算法，千万别忘了留言告诉我啊，哈哈 数独游戏： 　　版权所有 ...
徐松亮算法教学-基于C语言的数独(九宫格)求解（含多解和解数统计）
xslxhn的专栏
11-06 3790
版权声明：本文为博主徐松亮的原创作品，未经允许不得转载，多谢支持！QQ：5387603 推荐点击此链接：欢迎进入徐松亮博客一站式导航搜索(随时更新) 目录 一，前言 二，开发环境 电脑系统 编译器 编程语言 编辑与工程环境 三，编程思路与流程 流程 设计数独数据结构 编写测试代码框架 编写核心代码---接口函数 编写核心代码---寻找下一个空单元 编写核心代码---利...
算法学习：37. 解数独
qq_40492693的博客
03-31 1309
解数独的递归函数的返回值需要用boolean类型，因为解数独找到一个符合的条件（假设树的叶子节点）就立刻返回，相当于找从根节点到叶子节点的一条唯一路径，所以需要boolean类型。 解数独需要“遍历整个树型结构寻找可能的叶子节点就立刻返回”，递归的下一层的棋盘一定要比上一层棋盘多一个数，等数填满了棋盘自然就终止了，所以不需要终止条件。 使用一个for循环遍历行，一个for循环遍历列，一行一列确定下来，递归遍历这个位置放9个数字的可能性。
（每日一练c++）37. 解数独
weixin_39827856的博客
06-14 591
编写一个程序，通过填充空格来解决数独问题。 数独的解法需 遵循如下规则： 数字1-9在每一行只能出现一次。 数字1-9在每一列只能出现一次。 数字1-9在每一个以粗实线分隔的3x3宫内只能出现一次。（请参考示例图） 数独部分空格内已填入了数字，空白格用'.'表示。 示例 1： 输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8"......
编程解决数独问题，效率和简洁并存
秋水共长天一色的博客
07-02 1302
编程解决数独问题，效率和简洁并存 没事玩玩数独，挺好的。最近吸引力最大的还是数独，看了网络上很多程序，受到许多启发。收集了几个难易程度不等的数独题作为测试，感觉效率还可以，代码还算简洁，最复杂的那个数独题破解时间大约3秒（不同性能的电脑花费时间会有差异）。 解题的思路大致是这样的： 步骤1：统计零点坐标和它们的可填数字序列。 步骤2：在零点列表中找到可填数最少的那个点。 步骤3：从这个点开始试尝它的第一个（第N个）可填数字，把这个数字填到数独中去，并记录在案。 步骤4：因为填入了数字，零点减少了，它们的可填
程序解决数独问题
zhuiQiuMX的博客
06-17 1227
程序解决数独问题序言故事的开始编程上的选择过程C代码我的实验最后 序言 你好！这里是我的又一篇博客。事情的起因是前几天突然想到了大学玩的数独问题，然后想着怎么用程序解决。于是，新的故事展开了。 故事的开始 如果我还是大学时的菜鸟程序员，我会马上打开电脑创建程序。但是这次我，首先考虑了编程语言。 因为我深入考虑后，解数独问题需要先用给的数字，加上给的1-9每个数字在每一行、每一列和每一宫中都只出现一次的条件参考百度百科，在空格位置备注可能的值，然后从可能数目最少的。当然，如果只有一个那就最开心了。然后一遍遍地
九宫格数独 回溯算法
05-27
九宫格数独问题是一个经典的回溯算法问题。该问题的目标是在一个九宫格中填入数字，使得每一行、每一列和每一个九宫格内的数字都不重复。 回溯算法是一种递归算法，它尝试解决问题的所有可能的解，并返回最优解。在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

徐松亮

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值