数独终盘生成器（调试成果）

最新推荐文章于 2024-06-03 09:33:26 发布
最新推荐文章于 2024-06-03 09:33:26 发布
阅读量2k 收藏 1
点赞数 1
分类专栏： 数独 文章标签： table 测试 system null qq

欢迎吹毛求疵   QQ：1423173783    邮箱：1423173783@qq.com

这个代码是我做事时脑中突然递归到这里，才贴出来的。我认为有必要把调试遇到的错误的特例贴出来。   代码没做啥美观修饰，抱歉，本来就是递归到这

我想马上，返回那里还有一些问题没解决。 

#include <iostream>
#include <cstdlib>
#include <ctime>
#include<time.h>
#include<cstdlib>
#define  K   4
using namespace std;
int table[K*K][K*K];
void shuffle(int arr[])
{
    int tmp, rd;
    for(int i = 0; i < K*K; i++)
 {
        rd = rand() % (K*K);
        tmp = arr[rd];
        arr[rd] = arr[i];
        arr[i] = tmp;
    }
}
bool test(int x, int y, int v)
{
   
    int _x = x / K * K;
    int _y = y / K * K;
 //测试3 * 3矩阵内是否有重复的数
    for(int i = _x; i <=x-1; i++)
        for(int j = _y; j <= _y + K-1; j++)
            if(table[i][j] == v)   return false;
    //测试横向、纵向是否有重复的数
    for(int j = 0; j <=y-1; j++)
        if(table[x][j] == v )      return false;
    for(int i=0;i<=x-1;i++)
  if(table[i][y]==v) return (false);
    return true;
}
int main()
{
    long time1=clock();
 int b[K*K];
 for(int i=0;i<=K*K-1;i++)
  b[i]=i+1;
 //int num=0;
 //do
 //{
 for(int i=0;i<=K*K-1;i++)
  table[0][i]=i+1;
    srand((unsigned int)time(NULL));
    shuffle(table[0]);
    for (int x=1;x<=K*K-1;x++)                  //这是核心  这两个for循环中的代码是实践调试改出来的，调试图片下面会附上
     {
    for (int y=0;y<=K*K-1;y++)
        {
             int i;
    shuffle(b);
             for( i=0;i<=K*K-1;i++)
    {
                 if(test(x,y,b[i]))
     { table[x][y]=b[i];  break;}
    }
            if(i==K*K && y>0)
   {
    for(int m=0;m<=y-1;m++)
         table[x][m]=0;
    y=-1;
    if(x>=2)
    {
     for(int i=0;i<=K*K-1;i++)
      table[x-1][i]=0;
     x-=2;
     break;
    }
   }
   else if(i==K*K && y==0)
   {
    for(int i=0;i<=K*K-1;i++)
     table[x-1][i]=0;
    x-=2;
    break;
   }
       }
    }
 /*for(int i=0;i<=8;i++)
  for(int j=0;j<=8;j++)
   table[i][j]=0;*/
 //num++;
 //}while(num<1000);
    for(int x=0;x<=K*K-1;x++)
 {
        for(int y = 0; y <=K*K-1; y++)
            cout << table[x][y] << " ";
        cout << endl;
    }
 time1=clock()-time1;
 cout<<"use time "<<time1/1000<<"s"<<time1%1000<<"ms"<<endl;
    system("pause");
}

 


 

 

 

//这个算法生成的的是一系列本质一样的终盘，其实只生成一个，

//     代码后面举两个生成的终盘

#include <stdio.h>                                                                                                               
#include<cstdlib>
#include<time.h>
//using namespace std;
int Initial(int i, int j, int start);
int b[9]={1,2,3,4,5,6,7,8,9};
int data[9][9];
int line[9][9], column[9][9], block[9][9],data1[9][9];
void shuffle(int arr[])
{
    int tmp, rd;
    for(int i = 0; i <=8 ; i++)
 {
        rd = rand() % 9;
        tmp = arr[rd];
        arr[rd] = arr[i];
        arr[i] = tmp;
    }
}

int main()
{
    int i, j;
 long time1;
   /* for (i = 0; i < 9; i++)
        for (j = 0; j< 9; j++)
        {
            data[i][j] = 0;            //数独阵线初始化为零
            line[i][j] = 0;            //行标记数组初始化
            column[i][j] = 0;        //列标记数组初始化
            block[i][j] = 0;        //块标记数组初始化
        }*/
    time1=clock();
 srand(time(0));
 shuffle(b);
    Initial(0, 0, 8);                //赋值函数
 printf("%ums\n",clock()-time1);
    for (i = 0; i < 9; i++)            //打印数独阵
    {
        for (j = 0; j < 9; j++)
            printf("%i ", data[i][j]);
        printf("\n");
    }
    system("pause");
 return 0;
}


int Initial(int i, int j, int start)
{
    int k;
    for (k = start;k>=0;k--)        //从1至9依次试验
    {
        if (!line[i][b[k]-1] && !column[j][b[k]-1] && !block[i/3*3+j/3][b[k]-1])
        {
            data[i][j] = b[k];
   data1[i][j]=k;
            line[i][b[k]-1] = 1;
            column[j][b[k]-1] = 1;
            block[i/3*3+j/3][b[k]-1] = 1;

            if (i == 8 && j == 8)        //初始化完毕退出
                return 1;

            if (j == 8)                    //定位下一位置                   
            {
                j = 0;
                i++;
            }
            else
                j++;
            Initial(i, j, 8);            //初始化下一位置
            return 1;
        }
       
        if (k == 0)                        //1至9均无合适值，回溯
        {
            do
            {
                if (j == 0)                //定位前一位置
                {
                    j = 8;
                    i--;
                }
                else
                    j--;
                line[i][data[i][j]-1] = 0;
                column[j][data[i][j]-1] = 0;
                block[i/3*3+j/3][data[i][j]-1] = 0;
            }while (data[i][j] == b[0]);

            //回溯到一可以继续的位置,从这一位置开始递归赋值
            Initial(i, j, data1[i][j] -1);
            return 1;                    //递归结束返回后立即退出
        }
    }
   // return 1;
}

 

 

 

 

下面是另一种生成器，时间复杂度不如上面两种算法。

 

#include <iostream>
#include <cstdlib>
#include <ctime>
#include<time.h>
#include<cstdlib>
#define  K   3
using namespace std;
int table[K*K][K*K];
void shuffle(int arr[],int m,int n)//小标为m--小标为n打乱顺序
{
    int tmp, rd;
    for(int i =m ; i <=n; i++)
 {
        rd = m+rand() % (n-m+1);
        tmp = arr[rd];
        arr[rd] = arr[i];
        arr[i] = tmp;
    }
}
bool test(int x, int y, int v)
{
   
    int _x = x / K * K;
    int _y = y / K * K;
 //测试3 * 3矩阵内是否有重复的数
    for(int i = _x; i <=x-1; i++)
        for(int j = _y; j <= _y + K-1; j++)
            if(table[i][j] == v)   return false;
    //测试横向、纵向是否有重复的数
    for(int j = 0; j <=y-1; j++)
        if(table[x][j] == v )      return false;
    for(int i=0;i<=x-1;i++)
  if(table[i][y]==v) return (false);
    return true;
}
int check(int y,int x,int *mark)  //求probable[y][x]
{
 int i,j,is,js,count=0;
 for(i=1;i<=K*K;++i)
  mark[i]=0;
 for(i=0;i<K*K;++i)
  mark[table[y][i]]=1;
 for(i=0;i<K*K;++i)
  mark[table[i][x]]=1;
 is=y/K*K;
 js=x/K*K;
 for(i=0;i<K;++i)
 {
  for(j=0;j<K;++j)
   mark[table[is+i][js+j]]=1;
 }
 for(i=1;i<=K*K;++i)
  if(mark[i]==0)
  {  count++; mark[i]=i;}
  else mark[i]=0;
  shuffle(mark,1,K*K);
 return count;
}
int main()
{
    long time1=clock();
 int b[K*K+1];
 for(int i=0;i<=K*K-1;i++)
  table[0][i]=i+1;
    srand((unsigned int)time(NULL));
    shuffle(table[0],0,K*K-1);
    for (int x=1;x<=K*K-1;x++)
     {
    for (int y=0;y<=K*K-1;y++)
        {
             int i;
             check(x,y,b);
    for( i=1;i<=K*K;i++)
    {
                 if(b[i]!=0)
     { table[x][y]=b[i];  break;}
    }
            if(i==K*K+1 && y>0)
   {
    for(int m=0;m<=y-1;m++)
         table[x][m]=0;
    y=-1;
    if(x>=2)
    {
     for(int i=0;i<=K*K-1;i++)
      table[x-1][i]=0;
     x-=2;
     break;
    }
   }
   else if(i==K*K+1 && y==0)
   {
    for(int i=0;i<=K*K-1;i++)
     table[x-1][i]=0;
    x-=2;
    break;
   }
       }
    }
    for(int x=0;x<=K*K-1;x++)
 {
        for(int y = 0; y <=K*K-1; y++)
            cout << table[x][y] << " ";
        cout << endl;
    }
 time1=clock()-time1;
 cout<<"use time "<<time1/1000<<"s"<<time1%1000<<"ms"<<endl;
    system("pause");
}

 

 

 

 

 

 

下面也是一种思路，不过耗时太长

 

 

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#include<time.h>
#include<cstdlib>
using namespace std;
int sudoku[9][9],avail[9]={1,2,3,4,5,6,7,8,9};//定义数独数组和可选数字数组
void remove(int t[],int);//声明移除前置函数
void restore(void);//声明重置函数
void print(void);//声明打印数独函数
void init(void);//声明初始化函数
int search(int t[],int);//声明搜索下标函数
int en=9;//可选avail下标
void init() //初始化
{
    int x,y;
    srand(time(NULL));
    for (y=0;y<=8;y++)
     {
       for (x=0;x<=8;x++)
        {
          sudoku[y][x]=0;
        }
     }//初始化数组
}
void remove(int t[],int n) //n为下标，移除排除下标，项前移
{
    int i;
    for (i=n;i<=7;i++)
     {
       t[i]=t[i+1];
     }
    en--;//可选数字在原有基础上减
}
int search(int t[],int n) //n为搜索的数字，返回下标，如果没有则返回-1
{
    int i;
    for (i=0;i<=en-1;i++)
    if (t[i]==n)
       return i;
    return -1;
}
void restore() //初始化en,avail
{
   int i;
   en=9;
   for (i=0;i<=8;i++)
     avail[i]=i+1;
}
void print(void)
{
   int i,j;
   for (i=0;i<=8;i++)
    {
      for (j=0;j<=8;j++)
       {
          cout << sudoku[i][j] << " ";
       }
     cout << endl;
    }
}
int main()
{
    int x=0,y=0;
    int kill;//已存在的数的小标
    long time;
    time=clock();
    init();
    cout << "正在生成一个数独..." << endl;
    //restore();
    for (y=0;y<=8;y++)
    {
     for (x=0;x<=8;x++)
        {
                               
             int i,j;
             for (i=0;i<=x;i++)//排除横行
                  {
                        kill=search(avail,sudoku[y][i]);
                        if (kill!=-1)
                             remove(avail,kill);
                   }
               for (i=0;i<=y;i++)//排除纵行
                  {
                        kill=search(avail,sudoku[i][x]);
                        if (kill!=-1)
                            remove(avail,kill);
                   }
              for (i=0;i<=2;i++) //排除九宫
                  {
                       for (j=0;j<=2;j++)
                             {
                                 kill=search(avail,sudoku[(y/3)*3+i][(x/3)*3+j]);
                                 if (kill!=-1)
                                     remove(avail,kill);
                              }
                    }
            if (en==0 && y>0) //排除无解
               {
                   y-=2;
                   break;
               }
           else if (en==0 && y==0)
               {
                    init();
                    y=-1;
                    break;
                }
             sudoku[y][x]=avail[rand()%en];
             restore();
       }
     restore();
    }
print();//打印数独
time=clock()-time;
cout<<"时间"<<time/1000<<"秒"<<time%1000<<"毫秒"<<endl;
system("pause");
}

 

 

for_every_one
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【软件工程基础】数独生成器以及解答器
zzh71765123的博客
01-11 5677
需求 实现一个能生成数独终局并且能够求解数独问题的控制台程序。 能生成不重复的数独终局至文件。 读取文件内的数独问题，求解并将结果输出到文件。 主要需求标黄。 环境 win10+IntelliJ IDEA PSP PSP2.1 Person Software Process Stages 预估耗时（分钟） 实际耗时（分钟） Planning 计划 60 ·Estimate ·...
数独 生成及求解
Silentic
09-19 6241
项目地址https://github.com/si1entic/sudoku需求分析 生成终局 格式：sudoku.exe -c n 1）不重复 2）1<=n<=1000000，能处理非法参数 3）左上角数字固定为（4+4）% 9 + 1 = 9 4）n在1000以内时，要求程序在 60 s 内给出结果 5）输出生成的数独终盘至sudoku.txt 求解数独 格式：sudoku.
数独模板生成
weixin_41191134的博客
12-13 2002
在网上找了好多的数独生成算法发现一个挺好的算法，然后自己稍微修改了一下，将其改为数独模板生成工具，用了为我的数独app生成模板。 本文中用到的数独生成算法从网上借鉴而来，但是记不清是哪个网址了，如果此算法的原作者看到，请海涵！ public class ShuDu {     /** 存储数字的数组 */     private static int[][] n = new int[9][9]...
探秘Tdoku：史上最快的数独求解器与生成器
最新发布
gitblog_00085的博客
06-03 282
探秘Tdoku：史上最快的数独求解器与生成器 项目地址:https://gitcode.com/t-dillon/tdoku 项目简介 Tdoku是一个高效、快速的数独求解器和谜题生成器，专注于解决传统的9x9数独问题，同时也支持带有负线索的Sukaku“铅笔标记”数独。这个项目还包括两个其他版本的求解器，它们在开发过程中探索了不同的优化思路。此外，还提供了一个基准测试框架，用于比较这些求解器以及...
数独计算器
qq_25741071的博客
02-02 2576
<!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="Generator" content="EditPlus®"> <meta name="Author" content=""> <meta name="Keywords" content=""> <meta name="Description" c.
python 数独生成求解
颹蕭蕭
11-09 919
class SD: base = np.array([ [1,2,3,4,5,6,7,8,9], [4,5,6,7,8,9,1,2,3], [7,8,9,1,2,3,4,5,6], [2,3,1,5,6,4,8,9,7], [5,6,4,8,9,7,2,3,1], [8,9,7,2,3,1,5,6,4], [3,1,2,6,4,5,9,7,8], [6,4,5,9,7,8,
数独游戏终盘生成算法1
08-08
数独游戏终盘生成算法是计算机科学中一种有趣的算法应用，主要目的是生成具有唯一解决方案的数独谜题。本文将探讨四种不同的数独终盘生成方法，并以代码示例展示其中的一种。 首先，数独是一种逻辑游戏，由9x9的...
唯一解的数独题目生成器
12-04
Sudoku 唯一解的数独题目生成器，具体讲解请移步：https://blog.csdn.net/Michaelia_hu/article/details/103390255
excel表类型数独生成器
04-21
使用excel表的方式，加入代码，自己生成数独题目
数独题目生成器与求解器
03-28
实现了一个数独题目生成器，包括填充数独棋盘、解数独、生成数独题目等功能；也实现了一个数独求解器，包括检查数独棋盘的有效性、查找空单元格、判断数字是否可填入单元格、递归求解数独等功能。
九宫格数独题目生成器.rar
04-16
《九宫格数独题目生成器》是一款基于C#编程语言开发的应用程序，主要用于自动生成数独题目。这款工具在原有基础上进行了优化，加入了多线程处理功能，从而提升了生成题目的效率，使得用户能够快速获取到难度各异的...
挺有意思的三维数独游戏
01-13
这是我无意中找到的一个游戏，平时放松时玩一玩，很有意思。下面是原作者写的软件说明：“本软件是三维数独理论的配套操作软件，独立随机出题，提供解题、用时、排行榜、答案提示等功能。”
数独解答软件
07-15
终于开发了一个suduku解答小软件。核数*2个线程计算。 1.修改了退出功能，计算最大可能结果为10（由于手机内存和cpu关系不能无限制全部计算出来） 2.后期将实现保留左右button，采用触摸左右滑动。 3.增加一个快速输入，这个采用相机拍照，获取图片中数字。（难点，图形转文字）比如报纸，书籍，地铁上等看到一个数独，拍照获取计算，即可得知答案。想法挺好的！！
6x6 sudoku
06-26
Intel多核比赛上传文件做得不好，仅供参考
C++数独求解器与生成器
xlvzihan的博客
08-09 7502
用C++写的数独求解器与生成器。
随机数独局面的生成算法
热门推荐
选择的专栏
08-15 1万+
数独，在9x9的格子填入1到9的数字，识得每行、每列和每个3x3的格子里面，都包含完整不重复的1到9的九个数字。 用于解题的数独，会在随机空出一些格子，解题人需要根据数字相关性，推断空格处应该填写的数字。 一般而言，空的越多难度相对变大，不过空格设置不合理，就可能出现多个解都可行的情况。 针对怎么生成一个数独游戏，试验了几种思路： 1）从空白局面开始，每次随机选取一个空格位置，在...
c++ 随机生成数独（不保证唯一解）
CoderZhuuu
04-08 1171
给出一个最简单的生成数独初盘的程序，不保证有唯一解，终盘的正确性通过填充的过程来确定，可以用舞蹈链算法求解该数独得到其中一个解 随机生成的方法就算交换行和列然后随机挖洞 这里有一点要注意的就是交换的行和列必须处于同一宫中，要不然交换之后保证不了正确性 然后就是随机挖洞，可以直接随机一个坐标，或者用洗牌算法（类似于扫雷初盘的生成） vector<vector<int> &...
运用c语言随机生成一个数独终盘
06-08
好的，以下是一个用 C 语言随机生成数独终盘的示例代码： ```c #include #include #include #define N 9 #define M 81 int sudoku[N][N]; // 数独终盘数组 // 检查某个数是否可以填在指定的行、列和九宫格中 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值