数独小规律

最新推荐文章于 2021-01-16 23:19:38 发布
最新推荐文章于 2021-01-16 23:19:38 发布
阅读量1.2k 收藏
点赞数
分类专栏： 数独 文章标签： list system bi qq

QQ：1423173783    邮箱：1423173783@qq.com

文章最后有总结。和展望。



#include<cstdlib>
#include<time.h>
#include<iostream>
using namespace std;
int count=0,vessel[362880][9]; 
int b[9]={1,2,3,4,5,6,7,8,9},m=0;
int data[9][9],data1[9][9],data_vessel[362880][6][9];
int line[9][9], column[9][9], block[9][9];
int Initial(int i, int j, int start);
void shuffle(int arr[]);
void move1(int list[],int a,int b);
void move2(int list[],int a,int b);
void Perm(int list[], int s, int e) ;                    


void move1(int list[],int a,int b)
{
 int tmp=*(list+b);
 for(int i=b-1;i>=a;i--)
  *(list+i+1)=*(list+i);
 *(list+a)=tmp;
}
void move2(int list[],int a,int b)
{
 int tmp=*(list+a);
 for(int i=a+1;i<=b;i++)
  *(list+i-1)=*(list+i);
 *(list+b)=tmp;
}
void Perm(int list[], int s, int e)                    
{                                                       
   if(s>e)
   {
  for(int k=0;k<=8;k++)
      vessel[count][k]=list[k];
  count++;
   }
   for (int i=s; i <= e; i++) 
      { 
          move1(list,s,i);
          Perm(list,s+1,e);
          move2(list,s,i);
      } 
} 
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 Initial(int i, int j, int start)
{
    int k;
    for (k = start;k>=0;k--)       
    {
        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 == 5 && j == 8)      
{
for(int i=0;i<=5;i++)
for(int j=0;j<=8;j++)
{
data_vessel[m][i][j]=data[i][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;
data[i][j]=0;
}
return(1);
}


            if (j == 8)                                     
            {
                j = 0;
                i++;
if(i==3)
for(int j=0;j<=8;j++)
b[j]=vessel[m][j];
            }
            else
                j++;
            Initial(i, j, 8);            
            return 1;
        }
        
        if (k == 0)                       
        {
            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;                   
        }
    }//for
}


int main()
{
    int i, j;
long time1;
    time1=clock();
Perm(b,0,8);
for( m=0;m<=362879;m++)
{
for(int i=0;i<=8;i++)
b[i]=i+1;
Initial(0,0,8);
}
for(int i=0;i<=362878;i++)
{
if(data_vessel[i][0][0]==0)   continue;
for(int j=i+1;j<=362879;j++)
{
int m;
for(m=0;m<=5;m++)
for(int n=0;n<=8;n++)
if(data_vessel[i][m][n]!=data_vessel[j][m][n]) 
goto  temp;
if(m==6)  data_vessel[j][0][0]=0;
temp: ;
}
}
int num=0;
for(int i=0;i<=362879;i++)
if(data_vessel[i][0][0]!=0) num++;
cout<<num<<endl;
printf("%ums\n",clock()-time1);
    for (i = 0; i < 9; i++)            
    {
        for (j = 0; j < 9; j++)
            printf("%i ", data_vessel[16634][i][j]);
        printf("\n");
    }
    system("pause");
}




#include<cstdlib>
#include<time.h>
#include<iostream>
using namespace std;
int count=0,vessel[362880][9]; 
int b[9]={1,2,3,4,5,6,7,8,9},m=0;
int data_vessel[362880][1][9];
int data[9][9]={ 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,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0};
int line[9][9]={ 1,1,1,1,1,1,1,1,1,
            1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0};
int block[9][9]={ 1,1,1,1,1,1,1,1,1,
             1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,
 0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0};
int column[9][9]={ 1,0,0,1,0,0,1,0,0,
              0,1,0,0,1,0,0,1,0,
  0,0,1,0,0,1,0,0,1,
  1,0,0,1,0,0,1,0,0,
  0,1,0,0,1,0,0,1,0,
  0,0,1,0,0,1,0,0,1,
  1,0,0,1,0,0,1,0,0,
  0,1,0,0,1,0,0,1,0,
  0,0,1,0,0,1,0,0,1};
void Initial(int i, int j, int start);
void move1(int list[],int a,int b);
void move2(int list[],int a,int b);
void Perm(int list[], int s, int e) ;                    


void move1(int list[],int a,int b)
{
 int tmp=*(list+b);
 for(int i=b-1;i>=a;i--)
  *(list+i+1)=*(list+i);
 *(list+a)=tmp;
}
void move2(int list[],int a,int b)
{
 int tmp=*(list+a);
 for(int i=a+1;i<=b;i++)
  *(list+i-1)=*(list+i);
 *(list+b)=tmp;
}
void Perm(int list[], int s, int e)                    
{                                                      
   if(s>e)
   {
  for(int k=0;k<=8;k++)
      vessel[count][k]=list[k];
  count++;
   }
   for (int i=s; i <= e; i++) 
      { 
          move1(list,s,i);
          Perm(list,s+1,e);
          move2(list,s,i);
      } 
} 
void Initial(int i, int j, int start)
{
    int k;
    for (k = start;k>=0;k--)        //从1至9依次试验
    {
        if (!line[i][k] && !column[j][k] && !block[i/3*3+j/3][k])
        {
            data[i][j] = k+1;
            line[i][k] = 1;
            column[j][k] = 1;
            block[i/3*3+j/3][k] = 1;


            if (i == 3 && j == 8)        //初始化完毕退出
{
for(int j=0;j<=8;j++)
data_vessel[m][i-3][j]=data[i][j];
m++;
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;
data[i][j]=0;
break;
}
            Initial(i, j+1, 8); 
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;
data[i][j]=0;
        }
    }//for
}
int main()
{
    int i, j;
long time1;
    time1=clock();
Perm(b,0,8);
Initial(3,0,8);
printf("%u\n",m);
printf("%ums\n",clock()-time1);
    system("pause");
}


#include<cstdlib>
#include<time.h>
#include<iostream>
using namespace std;
int count=0,vessel[362880][9]; 
int b[9]={1,2,3,4,5,6,7,8,9},m=0;
int data1[9][9],data_vessel[362880][3][9];
int data[9][9]={ 9,8,7,6,5,4,3,2,1,
            6,5,4,3,2,1,9,8,7,
3,2,1,9,8,7,6,5,4,
8,9,6,7,4,5,2,1,3,
7,4,5,2,1,3,8,9,6,
2,1,3,8,9,6,7,4,5,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0};
int line[9][9]=    { 1,1,1,1,1,1,1,1,1,
                1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0};
int block[9][9]=    { 1,1,1,1,1,1,1,1,1,
                1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0};


int column[9][9]=  { 0,1,1,0,0,1,1,1,1,
                1,1,0,1,1,0,0,1,1,
1,0,1,1,1,1,1,0,0,
0,1,1,0,0,1,1,1,1,
1,1,0,1,1,0,0,1,1,
1,0,1,1,1,1,1,0,0,
0,1,1,0,0,1,1,1,1,
1,1,0,1,1,0,0,1,1,
1,0,1,1,1,1,1,0,0};
int Initial(int i, int j, int start);
void shuffle(int arr[]);
void move1(int list[],int a,int b);
void move2(int list[],int a,int b);
void Perm(int list[], int s, int e) ;                    //对list[s]——list[e]进行全排列


void move1(int list[],int a,int b)
{
 int tmp=*(list+b);
 for(int i=b-1;i>=a;i--)
  *(list+i+1)=*(list+i);
 *(list+a)=tmp;
}
void move2(int list[],int a,int b)
{
 int tmp=*(list+a);
 for(int i=a+1;i<=b;i++)
  *(list+i-1)=*(list+i);
 *(list+b)=tmp;
}
void Perm(int list[], int s, int e)                     
{                                                       
   if(s>e)
   {
  for(int k=0;k<=8;k++)
      vessel[count][k]=list[k];
  count++;
   }
   for (int i=s; i <= e; i++) 
      { 
          move1(list,s,i);
          Perm(list,s+1,e);
          move2(list,s,i);
      } 
} 
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 Initial(int i, int j, int start)
{
    int k;
    for (k = start;k>=0;k--)       
    {
        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)       
{
for(int i=6;i<=8;i++)
for(int j=0;j<=8;j++)
{
data_vessel[m][i-6][j]=data[i][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;
data[i][j]=0;
}
return(1);
}


            if (j == 8)                                 
            {
                j = 0;
                i++;
            }
            else
                j++;
            Initial(i, j, 8);           
            return 1;
        }
        
        if (k == 0)                        
        {
            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;                   
        }
    }//for
}
int main()
{
    int i, j;
long time1;
    time1=clock();
Perm(b,0,8);
for( m=0;m<=362879;m++)
{
for(int i=0;i<=8;i++)
b[i]=vessel[m][i];
Initial(6,0,8);
}
for(int i=0;i<=362878;i++)
{
if(data_vessel[i][0][0]==0)   continue;
for(int j=i+1;j<=362879;j++)
{
int m;
for(m=0;m<=2;m++)
for(int n=0;n<=8;n++)
if(data_vessel[i][m][n]!=data_vessel[j][m][n]) 
goto  temp;
if(m==3)  data_vessel[j][0][0]=0;
temp: ;
}
}
int num=0;
for(int i=0;i<=362879;i++)
if(data_vessel[i][0][0]!=0) num++;
cout<<num<<endl;
printf("%ums\n",clock()-time1);
    for (i = 0; i < 9; i++)           
    {
        for (j = 0; j < 9; j++)
            printf("%i ", data_vessel[16634][i][j]);
        printf("\n");
    }
    system("pause");
}
这篇文章得到的结论：用这篇文章的算法（每个代码本质上一样，为了不同的目的做了写修改）能生成一些有规律的终盘：

这里指的一些到底有多少：  分两种情况：形式不一的终盘可以生成 9！*12096*216=948109639680  约9481亿个

                                                                          本质不一的终盘可以生成          12096*216=2612736             约261万个

算法中每天横带产生一个种子。每选一个种子都有9！可能，当然这么多可能肯定会产生重复的终盘，上面的计算是剔除重复的情况。

这种算法生成的终盘量是很大的，但都有共同的规律，如果解题人解出题后发现了这个规律，能否推出三个种子我打文字时第一次开始考虑这个问题。第一个种子是

不用推导，第二个种子和第三个种子如何推导，如果推导不了，能否写个算法全部打印到文件？

还有个问题我之前就思考过，如果每填一行给个种子，或每两行给个种子，终盘的生成数又如何算，显然能生成的终盘更多。





for_every_one
关注
专栏目录
数独基本规则_10 分钟学会数独
weixin_34593388的博客
12-17 7090
不了解数独的人，请先看我第一篇文章数独的规则以及元素现在你应该知道数独的基本规则，以及行、列和宫避免你没看前面那篇文章，我解释一下我用到的坐标体系R 代表行，C 代表列，B 代表宫R1C1 指第一行第一列那个格子R23C1 指第一列的第二行和第三行 2 个格子R1C23 指第一行的第二列和第三列 2 个格子B1 代表第一宫本文只是数独的基础技巧和快速入门，如果都学会还想继续深入，请等待我的后续文章...
数独基本规则_数独入门介绍
weixin_39895486的博客
01-09 8447
数独游戏是非常推荐的一个小朋友益智游戏，小学生可以开始玩数独，建议从简单的开始。如果一开始就玩很难的，会打击兴趣。这篇文章做一个数独入门介绍，分为三部分：数独规则，数独逻辑和数独实战。读完这篇文章，数独入门没有问题。第一部分 规则篇数独有9行，我们编号为A-I；9列，我们编号为1-9；九宫，编号为一宫-九宫。如下图：数独的规则：填满数字使得每行、每列、以及每宫(3*3)的9个格子都包含...
数独基本规则_数独怎么玩规则（快速解数独的口诀）
weixin_39704314的博客
01-16 3775
数独游戏是一项流传很久的益智游戏，非常考验人的脑力，特别适合孩子进行脑力开发，但是很多小孩不知道数独游戏怎么玩，接下来给大家介绍一下关于数独游戏的玩法。1、基本交叉排除法：利用同一排和列的三个九宫内，两个相同数字找出另一个相同数字的位置。2、宫内排除法：将一个宫作为目标，用某个数字对它进行排除，最终得到这个宫内只有一格出现该数字的方法。3、行列排除法行列排除法：将一行或一列作为目标，用某个数字对它...
数独基本规则_数独基本规则（数独游戏规则和技巧）
热门推荐
weixin_33812391的博客
01-16 2万+
数独起源于18世纪初瑞士数学家欧拉等人研究的拉丁方阵。19世纪80年代，一位美国的退休建筑师格昂斯根据这种拉丁方阵发明了一种填数趣味游戏，这就是数独的雏形。1984年一位日本学者将其介绍到了日本，数独游戏在日本发展起来。在上世纪九十年代，传入我国。现在数独游戏在全世界广泛流行。首先给朋友们介绍一下数独的盘面的和游戏规则。数独游戏规则非常简单，只有三项。(1)需要在每一行九个格中填入数字1至9，不允...
数独大师级技巧_数独入门：你必须掌握的那些规则和技巧
weixin_39609670的博客
12-29 1万+
很多人想涉足数独领域，但苦于不知该如何入门和上手，甭愁了，北京市数独运动协会贴心地为菜鸟们总结了这一篇数独的元素、规则和技巧，满满的都是干货。如果你看完还觉得不够过瘾，那就移步至数独的规则在空格内填入数字1-9，使得每行、每列和每个宫内数字都不重复。注意：数独题目满足条件的答案是唯一的。数独的元素数独的元素主要包括行、列和宫。这三者划分出数独有三种不同形态的区域，而数独规则就是要求在这些区域内出现...
数独基本规则_数独入门：你必须掌握的那些规则和技巧
weixin_35615010的博客
01-16 6191
很多人想涉足数独领域，但苦于不知该如何入门和上手，甭愁了，北京市数独运动协会贴心地为菜鸟们总结了这一篇数独的元素、规则和技巧，满满的都是干货。如果你看完还觉得不够过瘾，那就移步至数独的规则在空格内填入数字1-9，使得每行、每列和每个宫内数字都不重复。注意：数独题目满足条件的答案是唯一的。数独的元素数独的元素主要包括行、列和宫。这三者划分出数独有三种不同形态的区域，而数独规则就是要求在这些区域内出现...
数独模型LINGO求解程序
01-13
定义了一个原始集number，由于在后续的程序中不直接使用该集，故省略了后面的属性，该集有9个成员，由于成员的规律性，可以采用隐式罗列法来表示。 派生集是指基于其他集的集，例如shudu(line,col):a;定义了一个...
SudokuCNN:使用CNN模型以两种方法解决数独难题
04-01
然后，构建一个CNN模型，其结构可能包含卷积层、池化层和全连接层，用于捕捉局部和全局的数独规律。模型训练的目标是使输出层的每个单元对应于数独盘面上的正确数字。一旦模型训练完成，就可以输入一个未完成的数独...
九宫格智力数独200题题+答案.doc
10-10
该游戏通常由9x9的网格组成，每个小格子中填充数字1-9，要求玩家通过逻辑推理和分析，找到正确的数字填充方式。 九宫格智力数独的难度系数是衡量游戏难度的重要指标。该指标反映了游戏的挑战性和复杂性，通常是根据...
杀手数独40题.doc
09-28
解决这些数独谜题通常需要结合逻辑推理、试错法以及对数字规律的理解。杀手数独尤其考验玩家在处理额外信息时的思维灵活性，因为它涉及到对数字和的分析。对于数比数独和对角线数独，玩家需要额外考虑数字之间的比较...
华中科技大学2017级课程设计（课程设计报告、数独）
04-25
华中科技大学2017级C语言和数据结构课程设计（基于SAT的数独游戏设计）
基于DPLL的SAT算法的研究及应用
12-20
.基于 DPLL 的完备性 SAT 算法研究 （1）预处理：将公式转换为对应的CNF （2）加速搜索的一些启发式策略： BCP（Boolean Constraint Propagation，布尔约束传播）、变量决策策略、冲突分析、子句学习、回溯机制 （3）子句删除机制 （4）随机重启动机制
数独(Sudoku,九宫格游戏)求解程序(源码)
12-16
自动求解各种难度的数独游戏 瞬间完成 源码开放,无需积分,学习编程的油条们赶紧下载吧
数独求解，满足学习娱乐需要
01-22
经典数独求解算法，满足一般的数独解题要求和学习要求
c语言版数独求解程序
10-06
呵呵，比较简单的一个程序，能做各种数独题
数独基本规则_数独专题一：幼儿数独启蒙
weixin_29025501的博客
12-17 7774
数独(Sudoku)起源于18世纪瑞士的一种数学逻辑推理游戏，适合所有年龄段的人，对于儿童来说，玩数独是锻炼逻辑推理能力的好方法之一。 一、数独的基本概念​ 比较常见的数独分为四宫格(2×2)、六宫格(2×3)、九宫格(3×3) 上图就是典型的四宫格，由16个小方块(格)组成，这16个小方块又由粗框线分成4个不同的区域，为了方便大家看，我把这4个不同的区域分别涂上了不同的颜色，这个区域(一个色块...
数独游戏设计(草稿)
tianxiazuixian的博客
12-31 2419
一.游戏功能 1、数独的九宫格的基本玩法。 2、用户可上传数独题目。二.解决方案 1、数独的九宫格的基本玩法 九宫格：由50X50的方格，和粗细不同的两根线组成。方格被选中时，要呈现不同的状态。 数字：使用系统文字。2、用户可上传数独题目 提供一个空的九宫格，用户依次填入数字。三.游戏界面 1、载入界面
堆排序（非递归）
无云的专栏
01-04 2355
以下代码经测试，排序5000000（五千万）int型数据没有问题！ 第一个参数是数组首地址 第二个参数是数组元素个数 void HeapSort(int * const arr, const DWORD number)//堆排序 { int tmp; DWORD tmpIndex; DWORD i=1; DWORD num; DWORD
Android快乐数独开发实践：入门与技巧
数独规则简单，目标是在9x9的网格中填入1至9的数字，每行、每列和每个3x3的小宫格内，数字均需唯一且符合一定的规律。 章节16详细介绍了数独游戏在Android中的设计与实现。首先，作者通过背景概述展示了数独的历史...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值