数独生成器（回溯）

最新推荐文章于 2025-03-06 09:42:45 发布
最新推荐文章于 2025-03-06 09:42:45 发布
阅读量2.2k 收藏 42
点赞数 42
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_87659349/article/details/144413365
版权

数独的解法需 遵循如下规则：

  1. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次

数独生成器设计思路
 
一、整体流程
 
1. 生成完整数独

 首先将一个9x9的二维数组（代表数独网格）初始化为全0。
 然后使用回溯算法来填充这个网格，确保每一行、每一列和每一个3x3的子网格内都包含1 - 9的数字且不重复。
2. 调整难度
 通过随机移除一定数量的数字来增加数独的难度。
随机选择数独网格中的位置，将该位置上的非0数字移除。
3. 评估难度
 简单地通过计算数独网格中剩余的空格数量来评估难度。空格越多，难度越高。
4. 打印数独
将生成的数独网格以整齐的格式打印出来，方便查看。 

二、数独生成器核心代码分析
 
（一） isSafe 函数：合法性检查

bool isSafe(int grid[N][N], int row, int col, int num) {
    // 检查行
    for (int x = 0; x < N; x++)
        if (grid[row][x] == num) return false;

    // 检查列
    for (int x = 0; x < N; x++)
        if (grid[x][col] == num) return false;

    // 检查3x3子网格
    int startRow = row - row % 3;
    int startCol = col - col % 3;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            if (grid[i + startRow][j + startCol] == num) return false;

    return true;
}

 功能：该函数用于检查在数独网格 grid 的 (row, col) 位置放置数字 num 是否合法。它通过遍历当前行、当前列和对应的3x3子网格来判断是否存在重复数字。

时间复杂度：
检查行和列时，各有一个循环，循环次数为 N （在数独中 N = 9 ），时间复杂度为O(N)。
检查3x3子网格时，有两个嵌套的循环，循环次数均为3，时间复杂度为O(1)（常数时间，因为3x3是固定大小）。
总的时间复杂度为O(N)，因为O(N)+O(N)+O(1) = O(N)。
 
（二） solveSudoku 函数：回溯算法解决数独

bool solveSudoku(int grid[N][N]) {
    int row, col;
    bool isEmpty = false;
    for (row = 0; row < N; row++) {
        for (col = 0; col < N; col++) {
            if (grid[row][col] == 0) {
                isEmpty = true;
                break;
            }
        }
        if (isEmpty) break;
    }

    // 如果没有空格，数独已解决
    if (!isEmpty) return true;

    // 尝试1 - 9的数字
    for (int num = 1; num <= 9; num++) {
        if (isSafe(grid, row, col, num)) {
            grid[row][col] = num;
            if (solveSudoku(grid)) return true;
            grid[row][col] = 0;
        }
    }
    return false;
}

功能：该函数使用回溯算法来填充数独网格。它首先找到第一个空的位置（值为0），然后尝试从1到9的数字，通过 isSafe 函数检查合法性，若合法则填充并递归调用自身继续填充下一个空位置，若递归调用返回 false ，则回溯并尝试下一个数字。

时间复杂度：
在最坏的情况下，对于一个空的数独网格，每次填充一个位置都可能需要尝试9个数字，而数独网格有N*N个位置（N = 9，即81个位置）。
每次调用 isSafe 函数的时间复杂度为O(N)，假设每次填充一个位置平均需要尝试 k 次（ k 小于等于9）。
总的时间复杂度约为O((N*N)^k)，在实际中，由于数独本身的约束条件，实际复杂度会远小于这个理论上界，但仍然是指数级的。

（三） generateSudoku 函数：生成完整数独

void generateSudoku(int grid[N][N]) {
    // 初始化数独网格为0
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            grid[i][j] = 0;

    // 生成一个完整的数独
    solveSudoku(grid);
}

功能：该函数先将数独网格初始化为全0，然后调用 solveSudoku 函数来生成一个完整的数独。

时间复杂度：取决于 solveSudoku 函数的时间复杂度，即O((N*N)^k)。
 
（四） removeDigits 函数：增加难度

void removeDigits(int grid[N][N], int count) {
    srand(static_cast<unsigned int>(time(0)));
    while (count > 0) {
        int row = rand() % N;
        int col = rand() % N;
        if (grid[row][col]!= 0) {
            grid[row][col] = 0;
            count--;
        }
    }
}

 功能：该函数用于从已生成的完整数独中随机移除 count 个数字，以增加数独的难度。它使用 rand 函数随机选择位置，并将非0位置置为0。

时间复杂度：
在最坏的情况下，可能需要循环 N*N 次才能移除 count 个数字（例如当数独中只有 count 个非0数字时）。每次循环中生成随机数和判断条件的操作时间复杂度较低，可视为常数时间。总的时间复杂度为O(N*N)。
 
（五） evaluateDifficulty 函数：难度评估

int evaluateDifficulty(int grid[N][N]) {
    int count = 0;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            if (grid[i][j] == 0) count++;
    return count;
}

功能：该函数通过计算数独网格中空格的数量来评估数独的难度。

 时间复杂度：有两层嵌套的循环，循环次数均为 N ，时间复杂度为O(N*N)。

 最后就是将我们所写的函数依次调用

整体代码如图所示（DevC++版）

#include <iostream>
#include <ctime>
#include <cstdlib>

const int N = 9;

// 检查在当前位置(row, col)放置num是否合法
bool isSafe(int grid[N][N], int row, int col, int num) {
    // 检查行
    for (int x = 0; x < N; x++)
        if (grid[row][x] == num) return false;

    // 检查列
    for (int x = 0; x < N; x++)
        if (grid[x][col] == num) return false;

    // 检查3x3子网格
    int startRow = row - row % 3;
    int startCol = col - col % 3;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            if (grid[i + startRow][j + startCol] == num) return false;

    return true;
}

// 使用回溯算法解决数独
bool solveSudoku(int grid[N][N]) {
    int row, col;
    bool isEmpty = false;
    for (row = 0; row < N; row++) {
        for (col = 0; col < N; col++) {
            if (grid[row][col] == 0) {
                isEmpty = true;
                break;
            }
        }
        if (isEmpty) break;
    }

    // 如果没有空格，数独已解决
    if (!isEmpty) return true;

    // 尝试1 - 9的数字
    for (int num = 1; num <= 9; num++) {
        if (isSafe(grid, row, col, num)) {
            grid[row][col] = num;
            if (solveSudoku(grid)) return true;
            grid[row][col] = 0;
        }
    }
    return false;
}

// 生成数独
void generateSudoku(int grid[N][N]) {
    // 初始化数独网格为0
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            grid[i][j] = 0;

    // 生成一个完整的数独
    solveSudoku(grid);
}

// 移除一些数字来增加难度
void removeDigits(int grid[N][N], int count) {
srand(static_cast<unsigned int>(time(0)));
    while (count > 0) {
        int row = rand() % N;
        int col = rand() % N;
        if (grid[row][col]!= 0) {
            grid[row][col] = 0;
            count--;
        }
    }
}

// 简单地通过剩余空格数量评估难度
int evaluateDifficulty(int grid[N][N]) {
    int count = 0;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            if (grid[i][j] == 0) count++;
    return count;
}

// 打印数独
void printSudoku(int grid[N][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++)
           for(i=0;i<N;i++)

	{

		for(j=0;j<N;j++)

		{

			printf("%d  ",grid[i][j]);

		}

		printf("\n");

	}
    }
}

int main() {
    int grid[N][N];
    generateSudoku(grid);
    // 生成一个10到50之间的随机数作为要移除的数字数量
srand(static_cast<unsigned int>(time(0)));
    int countToRemove = rand() % 41 + 10;
    removeDigits(grid, countToRemove);
    int difficulty = evaluateDifficulty(grid);
   printf("难度为%d\n", difficulty);
    printSudoku(grid);
    return 0;
}

 运行截图：

新手小白 如有问题 敬请指教 

基于C语言的9*9数独生成器（回溯法）
LB_Wuyanzu的博客
06-19 3594
#include <stdio.h> #include <time.h> #include <stdlib.h> #include <stdbool.h> int sudo[9][9], hole[9][9]; bool set(int x, int y, int val) { if (sudo[y][x] != 0) return false; int x0, y0; for (x0=0; x0&l
九宫格数独题目生成器.rar
04-16
在C#编程语言中，实现数独生成器的关键在于设计合理的算法。一般而言，这涉及到以下几个步骤： 1. **基础设置**：创建9x9的二维数组，初始化部分已知数字，形成一个基础的数独题目框架。 2. **空位查找**：找到...
唯一解的数独题目生成器
12-04
Sudoku 唯一解的数独题目生成器，具体讲解请移步：https://blog.youkuaiyun.com/Michaelia_hu/article/details/103390255
简洁高效的数独矩阵生成器
12-24
最近看别人玩数独游戏，了解了游戏规则后，编写了一个简洁高效的数独矩阵生成器，可任意设值矩阵阶数，算法简洁高效，欢迎大家下载
数独游戏开发与优化：使用 Tkinter 实现数独界面和智能生成算法
最新发布
qq_44793283的博客
03-06 852
在本篇博文中，我们将带您逐步实现一个数独游戏，使用 Python 的 Tkinter 库进行图形界面设计，并结合先进的数独生成和验证算法，确保每局游戏都能提供一个有挑战性的体验。我们不仅优化了数独题目生成的逻辑，还在界面设计上做了美化，使用户的游戏体验更加友好和流畅。通过这篇博文，我们展示了如何使用 Tkinter 创建一个互动式数独游戏，并结合优化的数独生成与验证算法，确保每次游戏都能提供一个具有挑战性的解答。你可以在此基础上进一步优化游戏的玩法和界面，加入更多功能，如音效、提示等，提升玩家的沉浸感。
数独生成器
PacMan的专栏
05-01 2538
本文介绍了一种用Java实现的数独生成器。 数独盘面是个九宫，每一宫又分为九个小格。在这八十一格中给出一定的已知数字和解题条件，利用逻辑和推理，在其他的空格上填入1-9的数字。使1-9每个数字在每一行、每一列和每一宫中都只出现一次，所以又称“九宫格”。 算法： 本文的实现采用的是回溯法。也就是说，从盘面的第一个格出发，按顺序遍历所有格子。对每一个格子随机生成一个数字，并判断该数字在当前的盘面下是否是合法的。如果不合法，比如同一行已经有相同的数字了，则随机换一个数字。如果当前位置所有数字都不合法，那
解答数独、自定义手动输入数独题目。快速生成数独答案。
02-13
解答数独、自定义手动输入数独题目。快速生成数独答案。
数独生成和解题工具
06-15
ss.exe是一个数独解题引擎 使用方法： ss.exe -v .9.5..8.7....2......3.49.2.1....67.......4..38..1526....5....7...8.9 .2..3.....96. ss.exe .9.5..8.7....2......3.49.2.1....67.......4..38..1526....5....7...8.9.2. .3.....96. ss.exe -v -v为详细输出，将打印解题步骤 最后一个参数为数独谜面，使用数字和点号逐行描述一个数独题目；为空则代表空数独，运行后将生成一个随机的数独
python数独解题器_python-2.7 – 数独生成器
weixin_39771775的博客
12-09 534
所以我刚制作了一个可以生成9×9矩阵的Sudoku生成器.我的行,列和子3×3矩阵都应该遵循Sudoku的规则.只有我的专栏不遵守规则.有人可以帮忙吗？这是我的代码：import randommaxAttempts = 100 #stops the program after 100 attemptscount = 9999solCount = 0while count > maxAttem...
数独生成器-matlab
07-29
数独生成器 观看使用回溯算法从头开始生成连续解决方案的过程。 运行testSudoku.m 首先生成初始解，然后生成连续解。 继续点击空格键以生成另一个解决方案。 数独生成器让您一窥连续解的生成过程。 记得把...
sudoku:使用 Swing 框架的数独生成器
06-14
标题中的“sudoku:使用 Swing 框架的数独生成器”表明这是一个基于 Java Swing 框架开发的程序，用于生成和解决数独游戏。Swing 是 Java 提供的一种用于构建桌面应用的 GUI（图形用户界面）工具包，它提供了丰富的...
数独自动生成题库
09-09
学习了Mars老师的数独游戏教程，奈何题库太单调，于是查找资料，增加了难度选择自动生成题库功能，游戏胜利后会弹框提示
数独生成求解器
05-28
是一个最快速度求解,最快速度生成的代码.使用深度递归调用, 已经测试4000个以上的数独,最慢一次求解使用1秒不到,最快一次求解14微妙
数独游戏答案生成器 真牛逼
03-31
数独游戏终结者 不要再为数独游戏而纠结了 只要一输入 答案马上给出 当之无愧的数独游戏"终结者"
数独游戏的生成以及自动求解
06-10
一款非常精美的熟读游戏，游戏界面色彩绚丽。菜单分三个选项，第1、2个为玩家模式（需要将文件放在子目录下），3为自动演示模式，第2、3个都通过上下滑动的菜单选择，只要是有解的数独都能完成，如果无解会提示有错。游戏在cmd窗口下运行，无需下载其余头文件等，在vs上运行通过。
数独解答软件
07-15
终于开发了一个suduku解答小软件。核数*2个线程计算。 1.修改了退出功能，计算最大可能结果为10（由于手机内存和cpu关系不能无限制全部计算出来） 2.后期将实现保留左右button，采用触摸左右滑动。 3.增加一个快速输入，这个采用相机拍照，获取图片中数字。（难点，图形转文字）比如报纸，书籍，地铁上等看到一个数独，拍照获取计算，即可得知答案。想法挺好的！！
唯一解的数独题目生成器——理解回溯法
Michaelia_hu的博客
12-04 5212
在生成数独题目时，流程是：生成一个完整的数独——随机挖空——解题——如果只有一个解，则生成该题目，如果有多个解，则重新挖空。 数独题目的生成涉及的一个算法是回溯法，这里面的完整数独的生成、求解都用到了回溯法。 1. 生成完整数独 在生成部分，先生成所有宫的1，再生成所有宫的2，以此类推。 主要有三个值： boolean[][][] placeable = new boolean[9][9...
数独的生成
weixin_58474273的博客
10-18 727
问题描述：数独是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个九宫格内的数字均含1-9，不重复要求：设计算法随机生成不同难度的数独游戏，阐述如何评价所生成数独的难度。对于数独程序，主要需要解决两个问题：数独生成、数独求解。目前影响比较大，功能比较完善的数独程序有：Hodoku、Sudoku Explainer。要实现数独的生成，就要先理清每一个位置的约束条件，经我们小组讨论发现，每个位置的数需要满足四个约束条件：首先，这个格子里不
数独模板生成
weixin_41191134的博客
12-13 2101
在网上找了好多的数独生成算法发现一个挺好的算法，然后自己稍微修改了一下，将其改为数独模板生成工具，用了为我的数独app生成模板。 本文中用到的数独生成算法从网上借鉴而来，但是记不清是哪个网址了，如果此算法的原作者看到，请海涵！ public class ShuDu {     /** 存储数字的数组 */     private static int[][] n = new int[9][9]...
Android动态生成数独游戏的回溯算法实现
3. 动态题目生成：与使用预设题库的传统数独游戏不同，动态题目生成意味着每个玩家可以得到一个独一无二的数独谜题。这一功能需要开发者实现一个能够生成满足数独规则的合法谜题的算法。生成算法可以基于深度优先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值