DLX解9*9数独 数组模拟双向十字链表

最新推荐文章于 2025-05-12 10:32:14 发布
转载 最新推荐文章于 2025-05-12 10:32:14 发布 · 3.5k 阅读 · 3
文章标签：

#stream #存储 #c #算法 #优化 #工作

QQ 1423173783   EMAIL:1423173783@qq,com  欢迎提出不同意见。

// 本代码用DLX算法解决9*9数独，特点是覆盖了前81列，战斗就解决了，把战斗浓缩在前81列。缺点是用了new 调试不方便，new的数组不好观测
//解题填空顺序存储在O[]中      舞池本来应该用双向十字链表做材料，本代码用二维数组模拟
#include<iostream>
#include<cstdlib>
#include<time.h>
#include<fstream>
using namespace std;
fstream  out_stream;
int node[10][10];
long time1,time2;
int O[82],S[82],a[730][244],O_sub=1;// O[]依次存储覆盖每一列用的行号，行号隐藏了哪一个格子填了哪一个候选数
int *U=new int[729967];              //S[82]存放前81列的候选数可能数，对应于每个格子的候选数
int *D=new int[729967];              //a[][]用来表示跳舞的舞池  U[]  D[]  R[]   L[]  是舞池的设置
int *R=new int[729967];
int *L=new int[729967];
void remove(int c);         //用来覆盖列
void resume(int c);         //用来恢复列  
bool DFS(int k);            //每次优先覆盖候选数可能数最少的列
int room(int row,int col);   // 给定行号，列号，求宫号
void init(int start[82]);    //预先处理：布置公共舞池，对于特定的舞会（特定的数独题）还要事先做些准备工作
void print_all();            //把结果输出到相应的文件，即每个格子填什么数
void subtraction(int pos,int k); //减候选数 并取消某一格子对应的某一候选数 所对应的行的覆盖资格
void add(int pos,int k);         //与上一函数相反
int row_room(int rom);            //给定宫号，求宫的开始行号
int col_room(int rom);          //给定宫号，求宫的开始列号
void remove(int c)
{
 L[R[c]]=L[c];
 R[L[c]]=R[c];
 for(int i=D[c];i!=c;i=D[i])
  for(int j=R[i];j!=i;j=R[j])
  {
   if(j%1000==0) continue;
   U[D[j]]=U[j];
   D[U[j]]=D[j];
   //S[j%1000]--;    这里保留原来的痕迹     后来改动的原因是，减候选数只会会减前81列，原来不光subtraction会减remove也会减，remove不会减前81列候选数，这里删掉耗时肯定变少，S[244]-->S[82]空间消耗也变少，别小看耗时少了5ms
  }
}
void resume(int c)
{
 for(int i=U[c];i!=c;i=U[i])
  for(int j=L[i];j!=i;j=L[j])
  {  
   if(j%1000==0) continue;
   U[D[j]]=j;
   D[U[j]]=j;
   //S[j%1000]++;
  }
    L[R[c]]=c;
 R[L[c]]=c;
}
bool DFS(int k)
{
 if(!R[0])  return(true);
 int count=100,c;
 for(int i=R[0];i<=81;i=R[i])//i改为i<=81
  if(S[i]<count)
  {
   count=S[i];
   c=i;
   if(count==1) break;
  }
    remove(c);
  for(int i=D[c];i!=c;i=D[i])
 {
  if(L[i]%1000==0)
  {
     int pos=(i/1000-1)/9+1,k1;//1<=pos<=81
     k1=i/1000-9*(pos-1);
     O[k]=i/1000;
     subtraction(pos,k1);
     for(int j=R[i];j%1000>0 && j%1000<244;j=R[j])//j!=i改为j!=0 && j!=1又改为j>1000  又改为j!=1000 && j!=2000
     remove(j%1000);
     if(DFS(k+1)) return (true);
     for( int j=L[L[i]];j!=i;j=L[j])  
     resume(j%1000);
     add(pos,k1);
  }
 }
 resume(c);
 return(false);
}
int room(int row,int col)
{
 return((row-1)/3*3+1+(col-1)/3);
}

void init(int start[82])
{
    int row,col;
 memset(U,0,729967*4);
 memset(D,0,729967*4);
 memset(R,0,729967*4);
 memset(L,0,729967*4);
 for(col=0;col<=243;col++)
 {
  L[col]=col-1;
  R[col]=col+1;
 }
 L[0]=243;   R[243]=0;
 for(int i=1;i<=81;i++)
  S[i]=9;
 for( row=1;row<=729;row++)
 {
  int k=(row-1)/9+1;
  int row1=(k-1)/9+1,col1=(k%9==0)?9:(k%9);
  int acol1,acol2,acol3;
     acol1=9*(row1-1)+col1;
  acol2=9*(9+col1-1)+row1;
  acol3=9*(18+room(row1,col1)-1)+(row1-(room(row1,col1)-1)/3*3-1)*3+col1-((room(row1,col1)-1)%3*3);
  a[row][acol1]=1;  a[row][acol2]=1;  a[row][acol3]=1; 
 }
    for(col=1;col<=243;col++)
 {
  int tmp;
  row=1;
  while(a[row][col]==0)
  { row++; } ;
  tmp=row; ;
  D[col]=1000*row+col;
  U[1000*row+col]=col;
  for(int i=row+1;i<=row+8;i++)//i<=729改为row+8  实验证明耗时降了1ms
   if(a[i][col]==0) continue;
   else
   {
    D[1000*tmp+col]=1000*i+col;
    U[1000*i+col]=1000*tmp+col;
    tmp=i;
      }
        D[1000*tmp+col]=col;
  U[col]=1000*tmp+col;
 }
 for(row=1;row<=729;row+=9)   //for循环内的内容经过替换  耗时减少大概0.5ms  不小心把原来for循环中的内容删掉了
 {
  int row0,col0,rom0,col1,col2,col3;
  col1=(row-1)/9+1;
  row0=(col1-1)/9+1;
  col0=col1-9*(row0-1);
  rom0=room(row0,col0);
  col2=9*(9+col0-1)+row0;
  col3=9*(18+rom0-1)+(row0-row_room(rom0))*3+(col0-col_room(rom0)+1);
  for(int i=row;i<=row+8;i++)
  {
   R[i*1000]=i*1000+col1;        L[i*1000+col1]=i*1000;
   R[i*1000+col1]=i*1000+col2;   L[i*1000+col2]=i*1000+col1;
   R[i*1000+col2]=i*1000+col3;   L[i*1000+col3]=i*1000+col2;
   R[i*1000+col3]=i*1000;        L[i*1000]=i*1000+col3;
  }
 }
 for(int i=1;i<=81;i++)
  if(start[i]!=0)
  {
            int row1=(i-1)/9+1,col1=(i%9==0)?9:(i%9);
   int acol1,acol2,acol3;
   acol1=9*(row1-1)+col1;
   acol2=9*(9+col1-1)+row1;
   acol3=9*(18+room(row1,col1)-1)+(row1-(room(row1,col1)-1)/3*3-1)*3+col1-(room(row1,col1)-(room(row1,col1)-1)/3*3-1)*3;
   O[O_sub++]=9*(i-1)+start[i];
   subtraction(i,start[i]);//原来是放在三个remove后  DFS中也要做相应调整
   remove(acol1);
   remove(acol2); 
   remove(acol3);
  }
}
void print_all()
{ 
 out_stream<<"print storage"<<endl;
   for(int i=1;i<=9;i++)
     {
    for(int j=1;j<=9;j++)
     {
   out_stream<<node[i][j]<<" ";
     if(j%3==0) out_stream<<"   ";
     }   
    out_stream<<endl;
    if(i%3==0)  out_stream<<endl;
     }
   out_stream<<endl<<endl;
}
void subtraction(int pos,int k)
{
     int row=(pos-1)/9+1,col=(pos%9==0)? 9:(pos%9);
     int rom=room(row,col),scol1,scol2,scol3;
     scol1=9*(row-1)+1;  scol2=9*(9+col-1)+1;  scol3=9*(18+rom-1)+1;
     for(int j=scol1;j<=scol1+8;j++)
     {
      int m=D[j];//后来加的，发现j按原来代码j一下子变得很大，就出了循环 ，改过后for循环的代码看起来也更易理解
      if(D[j]==j)  continue;  //这一列以前被remove掉，不该处理的不处理，该处理的一定处理
      S[j]--;
      while(L[m]/1000-(L[m]/1000-1)/9*9!=k)  m=D[m];
      L[m]+=244;R[L[m]]=m;L[L[m]]=R[R[m]];   R[R[R[m]]]=L[m];
     }
     for(int j=scol2;j<=scol2+8;j++)
     {
      int m=D[j];
      if(D[j]==j)  continue;
      while(L[L[m]]/1000-(L[L[m]]/1000-1)/9*9!=k) 
       m=D[m];
      if(L[m]%1000!=9*row-1+col)  S[L[m]%1000]--;
      L[L[m]]+=244;R[L[L[m]]]=L[m];L[L[L[m]]]=R[m];   R[R[m]]=L[L[m]];
     }
     for(int j=scol3;j<=scol3+8;j++)
     {
      int m=D[j];
      if(D[j]==j)  continue;
      while(R[m]/1000-(R[m]/1000-1)/9*9!=k)  m=D[m];
      if(((L[L[m]]/1000-1)/9)/9+1!=row && L[L[m]]%1000-(L[L[m]]%1000-1)/9*9!=col) S[L[L[m]]%1000]--;//if(((L[L[m]]/1000-1)/9)/9+1!=row)改为if(((L[L[m]]/1000-1)/9)/9+1!=row && L[L[m]]%1000-(L[L[m]]%1000-1)/9*9!=col)
      R[m]+=244;L[R[m]]=m;R[R[m]]=L[L[m]];   L[L[L[m]]]=R[m];                                       //这样改使得同一个候选数不会使某个格子的probable值减两次，如果减两次下次选择覆盖列就不是最优化，我预测这样改会降低时间复杂度。
     }                                                                                                 //实际上耗时反而增加了，改前1674ms  改后3636ms  我还是觉得随着数独规模的增大比如16*16,25*25数独，改后的代码时间复杂度会更好        
}
void add(int pos,int k)
{
       int row=(pos-1)/9+1,col=(pos%9==0)? 9:(pos%9);
     int rom=room(row,col),scol1,scol2,scol3;
     scol1=9*(row-1)+1;  scol2=9*(9+col-1)+1;  scol3=9*(18+rom-1)+1;
     for(int j=scol3+8;j>=scol3;j--)
     {
      int m=D[j];
      if(D[j]==j)  continue;//不该恢复的不恢复，该恢复的一定恢复，不管处理了几次恢复到原样
      while(R[m]/1000-(R[m]/1000-1)/9*9!=k)  m=D[m];
      R[m]-=244;L[R[m]]=m;R[R[m]]=L[L[m]];   L[L[L[m]]]=R[m];
      if(((L[L[m]]/1000-1)/9)/9+1!=row && L[L[m]]%1000-(L[L[m]]%1000-1)/9*9!=col) S[L[L[m]]%1000]++;
     }
     for(int j=scol2+8;j>=scol2;j--)
     {
      int m=D[j];
      if(D[j]==j)  continue;
      while(L[L[m]]/1000-(L[L[m]]/1000-1)/9*9!=k)  m=D[m];
      L[L[m]]-=244;R[L[L[m]]]=L[m];L[L[L[m]]]=R[m];   R[R[m]]=L[L[m]];
      if(L[m]%1000!=9*row-1+col)  S[L[m]%1000]++;
     }
      for(int j=scol1+8;j>=scol1;j--)
     {
      int m=D[j];
      if(D[j]==j)  continue;
      while(L[m]/1000-(L[m]/1000-1)/9*9!=k)  m=D[m];
      L[m]-=244;R[L[m]]=m;L[L[m]]=R[R[m]];   R[R[R[m]]]=L[m];
      S[j]++;
     }
}
int row_room(int rom)
{
    return((rom-1)/3*3+1);
}
int col_room(int rom)
{
 return((rom-1)%3*3+1);
}
int main()
{
 char char_start[82];
 int int_start[82];   //开始用于存储从文件中读取的题目，后来用来存储解题结果
 ifstream cin_stream;
 cin_stream.open("d:\\c++\\数独12\\question\\1.txt");
 cin_stream>>char_start;
 for(int i=1;i<82;i++)
  int_start[i]=char_start[i-1]-'0';
 out_stream.open("d:\\c++\\数独12\\question\\question474.txt");
 time1=clock();
 init(int_start);
 DFS(O_sub);
 time2=clock();
 for(int i=1;i<=81;i++)
       int_start[(O[i]-1)/9+1]=O[i]-(O[i]-1)/9*9;
 for(int i=1;i<=81;i++)
 {
  int row,col;
  row=(i-1)/9+1;
  col=(i%9==0)?9:(i%9);
  node[row][col]=int_start[i];
 }
 for(int i=1;i<=81;i++)
  out_stream<<((O[i]-1)/9)/9+1<<"        "<<(O[i]-1)/9+1-((O[i]-1)/9)/9*9<<"      "<<O[i]-(O[i]-1)/9*9<<endl;
 out_stream<<endl;
 out_stream<<O_sub-1<<endl;//输出的是初盘已经有的数的个数
 print_all();
 cout<<time2-time1<<"ms"<<endl;
 delete[] U;
 delete[] D;
 delete[] R;
 delete[] L;
 system("pause");
}

 for(int col1=1;col1<=81;col1++)//我把for循环的样子改成现在这种样子，耗时几乎yiyang沮丧随着数独规模的变大，我预计改后的样子耗时更少
 {                                                        //  这段代码图片前的局部程序的改进，思想是第一张图片。第二张图片也是一种思想，但我认为第一张图片算法耗时少
  int col2,col3,row,col,rom;
  row=(col1-1)/9+1;  col=col1-9*(row-1); rom=room(row,col);
  col2=81+9*(col-1)+row;
  col3=162+9*(rom-1)+(row-(rom-1)/3*3-1)*3+col-(rom-1)%3*3;
  D[col1]=(9*(col1-1)+1)*1000+col1;    U[(9*(col1-1)+1)*1000+col1]=col1;
  D[col2]=(9*(col1-1)+1)*1000+col2;    U[(9*(col1-1)+1)*1000+col2]=col2;
  D[col3]=(9*(col1-1)+1)*1000+col3;    U[(9*(col1-1)+1)*1000+col3]=col3;
  for(int i=9*(col1-1)+2;i<=9*(col1-1)+9;i++)
  {
   D[(i-1)*1000+col1]=i*1000+col1;    U[i*1000+col1]=(i-1)*1000+col1;
   D[(i-1)*1000+col2]=i*1000+col2;    U[i*1000+col2]=(i-1)*1000+col2;
   D[(i-1)*1000+col3]=i*1000+col3;    U[i*1000+col3]=(i-1)*1000+col3;
  }
  D[(9*(col1-1)+9)*1000+col1]=col1;      U[col1]=(9*(col1-1)+9)*1000+col1;
  D[(9*(col1-1)+9)*1000+col2]=col2;      U[col2]=(9*(col1-1)+9)*1000+col2;
  D[(9*(col1-1)+9)*1000+col3]=col3;      U[col3]=(9*(col1-1)+9)*1000+col3;
   
  /*int tmp;
  row=1;
  while(a[row][col]==0)
  { row++; } ;
  tmp=row; ;
  D[col]=1000*row+col;
  U[1000*row+col]=col;
  for(int i=row+1;i<=row+8;i++)//i<=729改为row+8  实验证明耗时降了1ms
   if(a[i][col]==0) continue;
   else
   {
    D[1000*tmp+col]=1000*i+col;
    U[1000*i+col]=1000*tmp+col;
    tmp=i;
      }
        D[1000*tmp+col]=col;
  U[col]=1000*tmp+col;*/
 }

 

for_every_one
关注
Dancing Links X（跳舞链）
英雄哪里出来
01-31 32万+
双向十字交叉循环链表求解精确覆盖、重复覆盖。 骨牌覆盖、N皇后问题的高效解法。
DLX算法解数独游戏 Java版
魔神翼
07-11 2973
使用DLX算法解数独游戏。 初学Java，算法代码是由C代码转换的。 DLX.java是算法类，Sudoku.java是界面类。 解号称世界上最难的数独用时10ms以内。 算法详解 Sudoku 数独 Dancing Links模板 使用方法 int n = 9; DLX dlx = new DLX(n * n * n + 1, 4 * n * n);          
数独问题——DLX算法
a_forever_dream的博客
07-15 1137
如果还没有看过DLX算法请点这里~ 题目传送门 回想一下精确覆盖问题，它的要求是每一列恰好有一个1，那么我们可以考虑将每一列作为一个限制条件，那么将数独的限制条件套进去即可。 考虑数独的限制条件： 每一个空只能填一个数（这不是废话吗。。） 每一行中不能出现重复的数字，而且只能填1~9 每一列中不能出现重复的数字，而且只能填1~9 每一个宫中不能出现重复的数字，而且只能填1~9 这样看好像不是很...
数据结构——单链表2
最新发布
RuinTown的博客
05-12 847
之前因为顺序表底层是数组，我们可以直接free掉数组来销毁顺序表。但是链表不行，它的结点都是单独申请的空间，所以我们要一个一个的销毁。
DLX算法求解数独
BIT-1120161967的博客
04-16 3072
首先，DLX算法并不是为了解数独而提出的，它是为了解决精确覆盖问题而被提出的。精确覆盖问题：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1。数独这个问题恰好拟合了DLX算法的模型，所以可以用该方法求解。DLX算法的具体分析请看跳跃的舞者，舞蹈链（Dancing Links）算法——求解精确覆盖问题。该帖讲述的十分详细，就不在这里赘述算法的本身了。DLX算法实质...
DLX精确覆盖解数独问题
新博客地址:sensirly.github.io
08-23 2151
关于Dancing Links的介绍最好仔细阅读一下Knuth的论文，那篇翻译的文章也不错，这位仁兄的 博客比较易懂http://blog.youkuaiyun.com/sunny606/article/details/7833551 通过阅读论文主要有如下几点体会： 1.精确覆盖的最基本模型是：在一个01矩阵中选择若干个行，使得没列都包含且仅包含一个1 2.Dangcing links的逻辑与
关于用舞蹈链DLX算法求解数独的解析
weixin_30537391的博客
08-07 453
欢迎访问——该文出处-博客园-zhouzhendong 去博客园看该文章--传送门 描述 在做DLX算法题中，经常会做到数独类型的题目，那么，如何求解数独类型的题目？其实，学了数独的构建方法，那么DLX算法的精髓——构建矩阵也就慢慢的浮现了。 问题 假设有一个9*9的数独，我们限制每行每列以及每个3*3的小区域有且仅有1~9这些数各一个，现在我们要把1~9共9个数字各9个填入...
基于Pyhton语言实现9 x 9的数独游戏 并采用DLX双向十字链表算法进行求解.zip
05-13
进阶解法包括：区块摒除法（Locked Candidates）、数组（Subset/Tuple）、二链列（X-Wing）、唯一矩形（Unique Rectangle）、全双值格致死解法（Bivalue Universal Grave）、同数链（X-Chain）、异数链（Multidigit ...
基于Pyhton语言实现9 x 9的数独游戏源代码+软件设计文档+使用说明+GUI界面，采用DLX双向十字链表算法进行求解
04-13
并采用DLX双向十字链表算法进行求解。 软件架构 运行环境：python3 + Pycharm 安装教程 源码运行文件参考Sudoku_Game-python/源代码文件/源代码使用说明 本项目的主要关注点在于项目的软件设计文档以及设计之后的...
Python实现9x9数独游戏及DLX算法源码解析
在这个项目中，学生需要基于Python编程语言和DLX双向十字链表算法，实现一个完整的数独游戏，并可能要求进行测试和调试，确保游戏的正确性和稳定性。 6. 文件管理 在提供的文件名"Sudoku_Game-python-master"中，...
Python实现的9x9数独游戏及DLX算法求解
资源摘要信息:"本项目是一个基于Python语言实现的9x9数独游戏，其特色在于使用了DLX（Discrete Linearized eXecution）双向十字链表算法进行数独求解。数独是一种经典的逻辑填数字游戏，通常要求玩家在一个9x9的方格...
sudoku_solver:通过DLX解决数独
05-10
soduku_solver 通过DLX解决soduku。 建造 $ make 用法 用法： ./sudoku_sover [-v] [inputfile] 例子： $ ./sudoku_solver -v hardest_sudoku.txt input sudoku: +-------+-------+-------+ | 8 0 0 | 0 0 0 | 0 0 0 | | 0 0 3 | 6 0 0 | 0 0 0 | | 0 7 0 | 0 9 0 | 2 0 0 | +-------+-------+-------+ | 0 5 0 | 0 0 7 | 0 0 0 | | 0 0 0 | 0 4 5 | 7 0 0 | | 0 0 0 | 1 0 0 | 0 3 0 | +-------+-------+-------+ | 0 0 1 | 0 0 0 | 0 6 8 | |
DLX 求解数独
阿豪
10-29 169
原文链接: DLX 求解数独 上一篇: ...
Java版本的DLX解决数独算法
cggwz的信息飞船
01-29 620
DLX又称作精确覆盖问题，而今天要说的就是把解数独这个问题转化为一个精确覆盖问题，然后来解决它。 其实这是一个很好的解决问题的思路，很多问题都可以转化为一个精确覆盖问题，然后用接下来这个算法来解决它。 关于DLX的思想，网上有不少的解释，这里我就不再赘述，我会在我的另一篇博客里讲解原理。 首先是整个代码的结构。 总共分为四个类，分别是： 主类（StartPoint） 转换器类（Transfer）...
DLX之数独问题的解决
heyker的专栏
03-29 960
<br />数独是一个非常经典的智力游戏。它的游戏的规则是这样的：在一个9x9的方格中，你需要把数字1-9填写到空格当中，并且使方格的每一行和每一列中都包含1-9这九个数字。同时还要保证，空格中用粗线划分成9个3x3的方格也同时包含1-9这九个数字。<br />如下例题：<br /><br />其解为：<br /><br /><br />在计算科学理论中，这一类问题的解答被称之为NPC问题中的Hitting Set Problem，中文名应该叫做碰集问题。该类问题可以通过转换成为精确覆盖问题，其中以行表示概
POJ 3074 Sudoku (DLX解经典数独)
Gatevin的专栏
10-02 1331
题目大意： 给出一个数独求解, 题目保证有唯一解 要求每行每列每个九宫格都恰好包含数字1~9 大致思路： 学习DLX的简单练习 构造矩阵的方法如下： 一共324列 刚开始没考虑到每个格子只能填一个数样例没过, 再加上81列表示每个格子的唯一性才通过样例... 矩阵的构造方法见代码注释 代码如下： Result  :  Accepted     Memory  :
uva 1309 数独【DLX】
ACMer不要报考高校代码为13627的移通学院！
08-16 584
dancing link,数独，uva 1309
3074 DLX解决数独
Geek
01-03 800
数独的DLX构造：9*9个点每个点有9种选择，这构成了DLX的729行，每行、列、阵有限制，均为9行（/列/阵），然后每行（/列/阵）都有九种数的情况，于是就有了3*9*9列，但是因为一个位置只能选一个，所以又有9*9列，每列连接一个点的九种选数情况。     最终有4*9*9=324列，9*9*9=729行。 具体看https://blog.youkuaiyun.com/qq_40061421/arti...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值