两种dlx解法比较 以及靶形数独

最新推荐文章于 2024-01-11 00:14:02 发布
最新推荐文章于 2024-01-11 00:14:02 发布
阅读量2k 收藏 1
点赞数
分类专栏： 数独

原链接1：http://blog.sina.com.cn/s/blog_51cea4040100gxn1.html  这女娃子改变我对女性的看法      第一个代码和第三个第四个代码（靶形数独）来源于此链接。

原链接2：http://yzmduncan.iteye.com/blog/1151695

本文第一个代码建舞池既节省时间重要的的是耗时也少。建舞池耗时在0-1ms，对于大量测试来说正满足额外开销小的要求。解题时间两代码相差无几，是因为数组是随机存取，如换为链表作数据结构，第一个代码耗时少。第一个代码先把题目中已填的数做预处理减少的耗时不好统计，因为整个解题时间也就3ms。

DLX比一般DFS快的理由：

 1：增加了行，列，宫中各九个候选数一共81*3=243个检测量，不但囊括了显隐唯一数技巧，还使探索指标增多。

 2：删除修复，同行，列，宫候选数时有条不紊，remove和resume是绝配不需要另外的空间和时间。


#include<cstdlib>
#include<iostream>
#include<time.h>
using namespace std;
const int maxr=9*9*9+10;
const int maxc=9*9*4+10;
int L[maxc+maxr*5],R[maxc+maxr*5],U[maxc+maxr*5],D[maxc+maxr*5];
int S[maxc];
int nRow[maxc+maxr*5];
int nCol[maxc+maxr*5];
int head[10][10][10];
int outcome[59],o_sub;
int cnt;
int map[10][10]={0,0,0,0,0,0,0,0,0,0,
              0,8,0,0,0,0,0,0,0,0,
     0,0,0,3,6,0,0,0,0,0,
     0,0,7,0,0,9,0,2,0,0,
     0,0,5,0,0,0,7,0,0,0,
     0,0,0,0,0,4,5,7,0,0,
     0,0,0,0,1,0,0,0,3,0,
     0,0,0,1,0,0,0,0,6,8,
     0,0,0,8,5,0,0,0,1,0,
     0,0,9,0,0,0,0,4,0,0};

bool init();
int subgrid(int,int);
void Ins_node(int,int);
void Remove(int);
void Resume(int);
bool dfs(int);
void print();
int test();
bool fun(int a[10]);


int subgrid(int i,int j)
{
    i--; j--;
    return (i/3)*3+(j/3+1);

    if (i<=3 && j<=3) return 1;
    if (i<=3 && j<=6) return 2;
    if (i<=3 && j<=9) return 3;
    if (i<=6 && j<=3) return 4;
    if (i<=6 && j<=6) return 5;
    if (i<=6 && j<=9) return 6;
    if (i<=9 && j<=3) return 7;
    if (i<=9 && j<=6) return 8;
    if (i<=9 && j<=9) return 9;
}
void Ins_node(int c,int cnt)
{
    U[D[c]]=cnt;
    D[cnt]=D[c];
    U[cnt]=c;
    D[c]=cnt;
    S[c]++;
    nCol[cnt]=c;
}
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])
        {
            U[D[j]]=U[j];
            D[U[j]]=D[j];
            S[nCol[j]]--;
        }
}
void Resume(int c)
{
    for (int i=U[c];i!=c;i=U[i])
        for (int j=L[i];j!=i;j=L[j])
        {
            U[D[j]]=D[U[j]]=j;
            S[nCol[j]]++;
        }
    L[R[c]]=R[L[c]]=c;
}
bool dfs(int k)
{
    if (k>81) return true;

    int c,minnum=INT_MAX;
    for (int i=R[0];i!=0;i=R[i])
    {
       // if (!S[i]) return false;
        if (S[i]<minnum)
        {
            minnum=S[i];
            c=i;
        }
    }

    Remove(c);
 outcome[o_sub++]=c;
    for (int i=D[c];i!=c;i=D[i])
    {
        int tmp=nRow[i];
        map[tmp/100][(tmp/10)%10]=tmp%10;
        for (int j=R[i];j!=i;j=R[j])
            Remove(nCol[j]);
        if (dfs(k+1)) return true;
        for (int j=L[i];j!=i;j=L[j])
            Resume(nCol[j]);
    }
    Resume(c);
 o_sub--;
    return false;
}
void print()
{
 for(int i=1;i<=9;i++)
 {
  if((i-1)%3==0) printf("\n");
  for(int j=1;j<=9;j++)
   if((j-1)%3==0) {  printf(" "); printf("%d ",map[i][j]);}
   else   printf("%d ",map[i][j]);
        printf("\n");
 }
}
int test()
  {
 int sum=0,i,j,aray[10];
 for(int i=1;i<=9;i++)
  {
      sum=0;
   for(int j=1;j<=9;j++)
      { sum+=map[i][j];  aray[j]=map[i][j];}
   if(sum!=45) {cout<<"wrong"<<endl;   return 0;}
   if(!fun(aray))  return 0;
     }
 for( j=1;j<=9;j++)
  {
      sum=0;
   for(i=1;i<=9;i++)
         { sum+=map[i][j];  aray[i]=map[i][j];}
   if(sum!=45)  {cout<<"wrong"<<endl;   return 0;}
   if(!fun(aray))  return 0;
     }
 for(int k=1;k<=9;k++)
 {
  sum=0;
  int row=(k-1)/3*3+1,col=(k-1)%3*3+1,sub=1;
  for(i=row;i<=row+2;i++)
   for(j=col;j<=col+2;j++)
    { sum+=map[i][j];  aray[sub++]=map[i][j];}
        if(sum!=45)  {cout<<"wrong"<<endl;   return 0;}
  if(!fun(aray))  return 0;
 }
 return 1;
  }
bool  fun( int a[10])
{
 int i,j;
 for(i=1;i<=8;i++)
 {
  if(*(a+i)==0)  continue;
  for(j=i+1;j<=9;j++)
   if(*(a+i)==*(a+j)) return (false);
 }
 return (true);
}

int main()
{
    freopen("d:\\c++\\数独12\\question\\question475.txt","w",stdout);
 int op=1;
 srand(time(0));
 long time1,time2,time3=0;
 
  time1=clock();
        for (int i=0;i<=81*4;i++)
        {
            S[i]=0;
            L[i]=i-1; R[i]=i+1;
            U[i]=D[i]=i;
            nCol[i]=0;
        }
        L[0]=81*4; R[81*4]=0;

        cnt=81*4;
        for (int i=1;i<=9;i++)
            for (int j=1;j<=9;j++)
            {
                if (map[i][j])
                {
                    int k=map[i][j];
                    for (int u=1;u<=4;u++)
                    {
                        L[cnt+u]=cnt+u-1;
                        R[cnt+u]=cnt+u+1;
                        nRow[cnt+u]=100*i+10*j+k;
                    }
                    L[cnt+1]=cnt+4; R[cnt+4]=cnt+1;
                    head[i][j][k]=cnt+1;
                    Ins_node((i-1)*9+j,cnt+1);
                    Ins_node(81+(i-1)*9+k,cnt+2);
                    Ins_node(81*2+(j-1)*9+k,cnt+3);
                    Ins_node(81*3+(subgrid(i,j)-1)*9+k,cnt+4);
                    cnt+=4;
                }
                else
                    for (int k=1;k<=9;k++)
                    {
                        for (int u=1;u<=4;u++)
                        {
                            L[cnt+u]=cnt+u-1;
                            R[cnt+u]=cnt+u+1;
                            nRow[cnt+u]=100*i+10*j+k;
                        }
                        L[cnt+1]=cnt+4; R[cnt+4]=cnt+1;
                        head[i][j][k]=cnt+1;
                        Ins_node((i-1)*9+j,cnt+1);
                        Ins_node(81+(i-1)*9+k,cnt+2);
                        Ins_node(81*2+(j-1)*9+k,cnt+3);
                        Ins_node(81*3+(subgrid(i,j)-1)*9+k,cnt+4);
                        cnt+=4;
                    }
            }
        time2=clock(); 
        int k=0;
        for (int i=1;i<=9;i++)
            for (int j=1;j<=9;j++)
                if (map[i][j])
                {
                    k++;
                    Remove(nCol[head[i][j][map[i][j]]]);
                    for (int u=R[head[i][j][map[i][j]]];u!=head[i][j][map[i][j]];u=R[u])
                        Remove(nCol[u]);
                }
        dfs(k+1);
  time3=clock();
  if(test()) print();
  else cout<<op<<endl;
 
 cout<<"建舞池用时"<<time2-time1<<"ms"<<"解题用时"<<time3-time2<<"ms"<<endl;
 
}

 

 

 

 

 

 

 

 

 

#include <iostream>  
#include<time.h>
using namespace std;  
const int INF = 0x7fffffff;  
const int NN = 350;  
const int MM = 750;  
int n,m;    //列，行  
int cntc[NN];  
int L[NN*MM],R[NN*MM],U[NN*MM],D[NN*MM];  
int C[NN*MM];  
int head;  
int mx[MM][NN];  
int O[MM],idx;  
int ans[10][10];
int map[10][10]={0,0,0,0,0,0,0,0,0,0,
              0,8,0,0,0,0,0,0,0,0,
     0,0,0,3,6,0,0,0,0,0,
     0,0,7,0,0,9,0,2,0,0,
     0,0,5,0,0,0,7,0,0,0,
     0,0,0,0,0,4,5,7,0,0,
     0,0,0,0,1,0,0,0,3,0,
     0,0,0,1,0,0,0,0,6,8,
     0,0,0,8,5,0,0,0,1,0,
     0,0,9,0,0,0,0,4,0,0};
 
//删除列及其相应的行  
void remove(int c)  
{  
    int i,j;  
    L[R[c]] = L[c];  
    R[L[c]] = R[c];  
    for(i = D[c]; i != c; i = D[i])  
    {  
        for(j = R[i]; j != i; j = R[j])  
        {  
            U[D[j]] = U[j];  
            D[U[j]] = D[j];  
            cntc[C[j]]--;  
        }  
    }  
}  
//恢复列及其相应的行  
void resume(int c)  
{  
    int i,j;  
    R[L[c]] = c;  
    L[R[c]] = c;  
    for(i = D[c]; i != c; i = D[i])  
    {  
        for(j = R[i]; j != i; j = R[j])  
        {  
            U[D[j]] = j;  
            D[U[j]] = j;  
            cntc[C[j]]++;  
        }  
    }  
}  
bool dfs()  
{  
    int i,j,c;  
    if(R[head] == head)  
        return true;  
    int min = INF;  
    for(i = R[head]; i != head; i = R[i])  
    {  
        if(cntc[i] < min)  
        {  
            min = cntc[i];  
            c = i;  
        }  
    }  
    remove(c);  
    for(i = D[c]; i != c; i = D[i])  
    {  
        //i是某点的序号，将该点所在行的行号保存  
        O[idx++] = (i-1)/n;  
        for(j = R[i]; j != i; j = R[j])  
            remove(C[j]);  
        if(dfs())  
            return true;  
        for(j = L[i]; j != i; j = L[j])  
            resume(C[j]);  
        idx--;  
    }  
    resume(c);  
    return false;  
}  
bool build()  
{  
    int i,j,now,pre,first;  
    idx = head = 0;  
    for(i = 0; i < n; i++)  
    {  
        R[i] = i+1;  
        L[i+1] = i;  
    }  
    R[n] = 0;  
    L[0] = n;  
    //列双向链表  
    for(j = 1; j <= n; j++)  
    {  
        pre = j;  
        cntc[j] = 0;  
        for(i = 1; i <= m; i++)  
        {  
            if(mx[i][j])  
            {  
                cntc[j]++;  
                now = i*n+j;  
                C[now] = j;  
                D[pre] = now;  
                U[now] = pre;  
                pre = now;  
            }  
        }  
        U[j] = pre;  
        D[pre] = j;  
        if(cntc[j] == 0)  
            return false;  
    }  
    //行双向链表  
    for(i = 1; i <= m; i++)  
    {  
        pre = first = -1;  
        for(j = 1; j <= n; j++)  
        {  
            if(mx[i][j])  
            {  
                now = i*n+j;  
                if(pre == -1)  
                    first = now;  
                else 
                {  
                    R[pre] = now;  
                    L[now] = pre;  
                }  
                pre = now;  
            }  
        }  
        if(first != -1)  
        {  
            R[pre] = first;  
            L[first] = pre;  
        }  
    }  
    return true;  
}  
void print()  
{  
    int i,j;  
    int x,y,k;  
    for(i = 0; i < idx; i++)  
    {  
        int r = O[i];  
        k = r%9;  
        if(k==0) k = 9;  
        int num = (r - k)/9 + 1;  
        y = num%9;  
        if(y == 0) y = 9;  
        x = (num-y)/9 + 1;  
        ans[x][y] = k;  
    }  
    if(idx == 0)  
        printf("impossible\n");  
    else 
    {  
        for(i = 1; i <= 9; i++)  
        {  
            for(j = 1; j <= 9; j++)  
                printf("%d",ans[i][j]);  
            printf("\n");  
        }  
    }  
}

int main()  
{  
    int i,j,k;  
 long time1,time2,time3;
 char s[10][10];
  
  for(int i=1;i<=9;i++)
   for(int j=1;j<=9;j++)
    if(map[i][j])  s[i][j]=48+map[i][j];
    else   s[i][j]='?';
        memset(mx,0,sizeof(mx));
  time1=clock();
        for(i = 1; i <= 9; i++)  
        {  
            for(j = 1; j <= 9; j++)  
             {  
                int t = (i-1)*9 + j;  
                if(s[i][j] == '?')  
                {  
                    for(k = 1; k <= 9; k++)  
                    {  
                        mx[9*(t-1)+k][t] = 1;               //81grid 每个小格只能放一个数字  
                        mx[9*(t-1)+k][81+(i-1)*9+k] = 1;    //9row 每行数字k只能出现一次  
                        mx[9*(t-1)+k][162+(j-1)*9+k] = 1;   //9col  每列数字k只能出现一次  
                        mx[9*(t-1)+k][243+((i-1)/3*3+(j+2)/3-1)*9+k] = 1;   //subgrid 每个3*3格子数字k只能出现一次  
                    }  
                }  
                else 
                {  
                    k = s[i][j] - '0';  
                    mx[9*(t-1)+k][t] = 1;               //81grid  
                    mx[9*(t-1)+k][81+(i-1)*9+k] = 1;    //9row  
                    mx[9*(t-1)+k][162+(j-1)*9+k] = 1;   //9col  
                    mx[9*(t-1)+k][243+((i-1)/3*3+(j+2)/3-1)*9+k] = 1;   //subgrid  
                }  
            }  
        }  
        n = 324;  
        m = 729;  
        build();
  time2=clock();
        dfs();
  time3=clock();
        print();
  
 cout<<"建舞池用时"<<time2-time1<<"ms"<<"解题用时"<<time3-time2<<"ms"<<endl;
 getchar(); getchar();
    return 0;  
} 

 

 

 

 

 

 

 

 

 

 

#include<iostream>
using namespace std;
const int maxr=9*9*9+10;
const int maxc=9*9*4+10;
int L[maxc+maxr*5],R[maxc+maxr*5],U[maxc+maxr*5],D[maxc+maxr*5];
int S[maxc];
int nRow[maxc+maxr*5];
int nCol[maxc+maxr*5];
int head[10][10][10];
int cnt;
int map[10][10];
int data1[9][9]=
 {7,0,0,9,0,0,0,0,1,
  1,0,0,0,0,5,9,0,0,
  0,0,0,2,0,0,0,8,0,
  0,0,5,0,2,0,0,0,3,
  0,0,0,0,0,0,6,4,8,
  4,1,3,0,0,0,0,0,0,
  0,0,7,0,0,2,0,9,0,
  2,0,1,0,6,0,8,0,4,
  0,8,0,5,0,4,0,1,2};
int data2[9][9]=
 {0,0,0,7,0,2,4,5,3,
  9,0,0,0,0,8,0,0,0,
  7,4,0,0,0,5,0,1,0,
  1,9,5,0,8,0,0,0,0,
  0,7,0,0,0,0,0,2,5,
  0,3,0,5,7,9,1,0,8,
  0,0,0,6,0,1,0,0,0,
  0,6,0,9,0,0,0,0,1,
  0,0,0,0,0,0,0,0,6};
int best=-1,SCORE=0;
int score[10][10]=
{
 {0,0,0,0,0,0,0,0,0,0},
 {0,6,6,6,6,6,6,6,6,6},
 {0,6,7,7,7,7,7,7,7,6},
 {0,6,7,8,8,8,8,8,7,6},
 {0,6,7,8,9,9,9,8,7,6},
 {0,6,7,8,9,10,9,8,7,6},
 {0,6,7,8,9,9,9,8,7,6},
 {0,6,7,8,8,8,8,8,7,6},
 {0,6,7,7,7,7,7,7,7,6},
 {0,6,6,6,6,6,6,6,6,6}
};


int subgrid(int i,int j)
{
    i--; j--;
    return (i/3)*3+(j/3+1);
}
void Ins_node(int c,int cnt)
{
    U[D[c]]=cnt;
    D[cnt]=D[c];
    U[cnt]=c;
    D[c]=cnt;
    S[c]++;
    nCol[cnt]=c;
}
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])
        {
            U[D[j]]=U[j];
            D[U[j]]=D[j];
            S[nCol[j]]--;
        }
}
void Resume(int c)
{
    for (int i=U[c];i!=c;i=U[i])
        for (int j=L[i];j!=i;j=L[j])
        {
            U[D[j]]=D[U[j]]=j;
            S[nCol[j]]++;
        }
    L[R[c]]=R[L[c]]=c;
}
void dfs(int k)
{
    if (k>81)
    {
        cout<<SCORE<<endl;
  if (SCORE>best) best=SCORE;
        return;
    }

    int c,minnum=INT_MAX;
    for (int i=R[0];i!=0;i=R[i])
    {
        if (!S[i]) return;
        if (S[i]<minnum)
        {
            minnum=S[i];
            c=i;
        }
    }

    Remove(c);
    for (int i=D[c];i!=c;i=D[i])
    {
        int tmp=nRow[i];
        SCORE=SCORE+(tmp%10)*(score[tmp/100][(tmp/10)%10]);
        for (int j=R[i];j!=i;j=R[j])
            Remove(nCol[j]);
        dfs(k+1);
        SCORE=SCORE-(tmp%10)*(score[tmp/100][(tmp/10)%10]);
        for (int j=L[i];j!=i;j=L[j])
            Resume(nCol[j]);
    }
    Resume(c);
}

 

int main()
{
        freopen("d:\\c++\\数独12\\question\\question474.txt","w",stdout);
        for(int i=1;i<=9;i++)
   for(int j=1;j<=9;j++)
    map[i][j]=data1[i-1][j-1];
        for (int i=0;i<=81*4;i++)
        {
            S[i]=0;
            L[i]=i-1; R[i]=i+1;
            U[i]=D[i]=i;
            nCol[i]=0;
        }
        L[0]=81*4; R[81*4]=0;
        cnt=81*4;
        for (int i=1;i<=9;i++)
            for (int j=1;j<=9;j++)
            {
                if (map[i][j])
                {
                    int k=map[i][j];
                    for (int u=1;u<=4;u++)
                    {
                        L[cnt+u]=cnt+u-1;
                        R[cnt+u]=cnt+u+1;
                        nRow[cnt+u]=100*i+10*j+k;
                    }
                    L[cnt+1]=cnt+4; R[cnt+4]=cnt+1;
                    head[i][j][k]=cnt+1;
                    Ins_node((i-1)*9+j,cnt+1);
                    Ins_node(81+(i-1)*9+k,cnt+2);
                    Ins_node(81*2+(j-1)*9+k,cnt+3);
                    Ins_node(81*3+(subgrid(i,j)-1)*9+k,cnt+4);
                    cnt+=4;
                }
                else
                    for (int k=1;k<=9;k++)
                    {
                        for (int u=1;u<=4;u++)
                        {
                            L[cnt+u]=cnt+u-1;
                            R[cnt+u]=cnt+u+1;
                            nRow[cnt+u]=100*i+10*j+k;
                        }
                        L[cnt+1]=cnt+4; R[cnt+4]=cnt+1;
                        head[i][j][k]=cnt+1;
                        Ins_node((i-1)*9+j,cnt+1);
                        Ins_node(81+(i-1)*9+k,cnt+2);
                        Ins_node(81*2+(j-1)*9+k,cnt+3);
                        Ins_node(81*3+(subgrid(i,j)-1)*9+k,cnt+4);
                        cnt+=4;
                    }
            }
        int k=0;
        for (int i=1;i<=9;i++)
            for (int j=1;j<=9;j++)
                if (map[i][j])
                {
                    k++;
                    SCORE+=(map[i][j])*score[i][j];
                    Remove(nCol[head[i][j][map[i][j]]]);
                    for (int u=R[head[i][j][map[i][j]]];u!=head[i][j][map[i][j]];u=R[u])
                        Remove(nCol[u]);
                }
        dfs(k+1);
        printf("%d\n",best);
        fclose(stdout);
        return 0;
}

 

 

 

 

 

 

//http://blog.csdn.net/nhczp/article/details/1498868 这个链接产生多解的题目 并输出原始终盘（用来挖洞），以及题目，还有这个题目的一切解题结果
//http://blog.sina.com.cn/s/blog_51cea4040100gxn1.html 这个链接解靶形数独并输出最好得分
//输出到屏幕终端的是有都少个解法   输出到一个文件的是原始终盘（用来挖洞），以及题目，还有这个题目的一切解题结果， 输出到另一个文件的结果是每一个解题结果对应的分数最后输出最大分数
//速度真快，第一种解题用的是dfs第二种解题用的是dlx（解靶形数独） 两种都快啊 
//如果有靶形数独题目，还可以直接输入，data1，和data2就是两个靶形数独题目，在main函数里只需要屏蔽一些代码启用另一些代码就可测试特定的靶形数独题目
#include "time.h"
#include<cstdlib>
#include<iostream>
#include<fstream>
using namespace std;


ofstream out_stream;
 enum{ANY=0,ALL=1};
int map_exchange[9][9];
 int smod;
 int solves;

 

const int maxr=9*9*9+10;
const int maxc=9*9*4+10;
int L[maxc+maxr*5],R[maxc+maxr*5],U[maxc+maxr*5],D[maxc+maxr*5];
int S[maxc];
int nRow[maxc+maxr*5];
int nCol[maxc+maxr*5];
int head[10][10][10];
int cnt;
int map[10][10];
int data1[9][9]=
 {7,0,0,9,0,0,0,0,1,
  1,0,0,0,0,5,9,0,0,
  0,0,0,2,0,0,0,8,0,
  0,0,5,0,2,0,0,0,3,
  0,0,0,0,0,0,6,4,8,
  4,1,3,0,0,0,0,0,0,
  0,0,7,0,0,2,0,9,0,
  2,0,1,0,6,0,8,0,4,
  0,8,0,5,0,4,0,1,2};
int data2[9][9]=
 {0,0,0,7,0,2,4,5,3,
  9,0,0,0,0,8,0,0,0,
  7,4,0,0,0,5,0,1,0,
  1,9,5,0,8,0,0,0,0,
  0,7,0,0,0,0,0,2,5,
  0,3,0,5,7,9,1,0,8,
  0,0,0,6,0,1,0,0,0,
  0,6,0,9,0,0,0,0,1,
  0,0,0,0,0,0,0,0,6};
int best=-1,SCORE=0;
int score[10][10]=
{
 {0,0,0,0,0,0,0,0,0,0},
 {0,6,6,6,6,6,6,6,6,6},
 {0,6,7,7,7,7,7,7,7,6},
 {0,6,7,8,8,8,8,8,7,6},
 {0,6,7,8,9,9,9,8,7,6},
 {0,6,7,8,9,10,9,8,7,6},
 {0,6,7,8,9,9,9,8,7,6},
 {0,6,7,8,8,8,8,8,7,6},
 {0,6,7,7,7,7,7,7,7,6},
 {0,6,6,6,6,6,6,6,6,6}
};


 int check(int,int,int*);
 void dfs();
 void CSudoku(int n=40);// 随机生成数独,n越大越难
 void display();
 void print_all();
 int resolve(int mod=ALL);// 解数独


int subgrid(int,int);
void Ins_node(int,int);
void Remove(int);
void Resume(int);
void dfs(int);


void CSudoku(int n)
{
 int i,j;
 srand(time(0));
 do
 {
  for(i=0;i<9;++i)
  {
   for(j=0;j<9;++j)
    map_exchange[i][j]=0;
   j=rand()%9;
   map_exchange[i][j]=i+1;
  }
 }
 while(!resolve(ANY));

 // 挖窟窿
 for(int k=0;k<n;)
 {
  i=rand()%81;
  j=i%9;
  i=i/9;
  if(map_exchange[i][j]>0)
  {
   map_exchange[i][j]=0;
   ++k;
  }

 }
}
void display()
{
 out_stream<<"┏━┯━┯━┳━┯━┯━┳━┯━┯━┓"<<endl;

 for(int i=0;i<9;++i)
 {
  for(int j=0;j<9;++j)
  {
   if(map_exchange[i][j]>0)
   {
    if(j%3==0)
     out_stream<<"┃ "<<map_exchange[i][j];
    else
     out_stream<<"│ "<<map_exchange[i][j];
    
   }
   else
   {
    if(j%3==0)
     out_stream<<"┃  ";
    else
     out_stream<<"│  ";
   }
  }
  out_stream<<"┃"<<endl;
  if (i!=8)
  {
   if((i+1)%3==0)
    out_stream<<"┣━┿━┿━╋━┿━┿━╋━┿━┿━┫"<<endl;
   else
    out_stream<<"┠─┼─┼─╂─┼─┼─╂─┼─┼─┨"<<endl;
  }  }
 out_stream<<"┗━┷━┷━┻━┷━┷━┻━┷━┷━┛"<<endl;
}
void  print_all()
{ 
 out_stream<<"print storage"<<endl;
   for(int i=1;i<=9;i++)
     {
    for(int j=1;j<=9;j++)
     {
   out_stream<<map_exchange[i-1][j-1]<<" ";
     if(j%3==0) out_stream<<"   ";
     }   
    out_stream<<endl;
    if(i%3==0)  out_stream<<endl;
     }
   out_stream<<endl<<endl;
}
int resolve(int mod)
{
 smod=mod;
 if(mod==ALL)
 {
  solves=0;
  dfs();
  return solves;
 }
 else if(mod==ANY)
 {
  try
  {
   dfs();
   return 0;
  }
  catch(int)
  {
   return 1;
  }
 }
 return 0;
}
int check(int y,int x,int *mark)  //求probable[y][x]
{
 int i,j,is,js,count=0;
 for(i=1;i<=9;++i)
  mark[i]=0;
 for(i=0;i<9;++i)
  mark[map_exchange[y][i]]=1;
 for(i=0;i<9;++i)
  mark[map_exchange[i][x]]=1;
 is=y/3*3;
 js=x/3*3;
 for(i=0;i<3;++i)
 {
  for(j=0;j<3;++j)
   mark[map_exchange[is+i][js+j]]=1;
 }
 for(i=1;i<=9;++i)
  if(mark[i]==0)
   count++;
 return count;
}
void dfs()
{
 int i,j,im=-1,jm,min=10;
 int mark[10];
 for(i=0;i<9;++i)
 {
  for(j=0;j<9;++j)
  {
   if(map_exchange[i][j])
    continue;
   int c=check(i,j,mark);
   if(c==0)
    return;
   if(c<min)
   {
    im=i;
    jm=j;
    min=c;
   }
  }
 }
 if(im==-1)
 {
  if(smod==ALL)
  {
   printf("No. %d",++solves);
   printf("\n");
   display();
   return;
  }
  else if(smod==ANY)
  {
      display();
   throw(1);
  }
 }
 check(im,jm,mark);
 for(i=1;i<=9;++i)
 {
  if(mark[i]==0)
  {
   map_exchange[im][jm]=i;
   dfs();
  }
 }
 map_exchange[im][jm]=0;
}

 

 

int subgrid(int i,int j)
{
    i--; j--;
    return (i/3)*3+(j/3+1);
}
void Ins_node(int c,int cnt)
{
    U[D[c]]=cnt;
    D[cnt]=D[c];
    U[cnt]=c;
    D[c]=cnt;
    S[c]++;
    nCol[cnt]=c;
}
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])
        {
            U[D[j]]=U[j];
            D[U[j]]=D[j];
            S[nCol[j]]--;
        }
}
void Resume(int c)
{
    for (int i=U[c];i!=c;i=U[i])
        for (int j=L[i];j!=i;j=L[j])
        {
            U[D[j]]=D[U[j]]=j;
            S[nCol[j]]++;
        }
    L[R[c]]=R[L[c]]=c;
}
void dfs(int k)
{
    if (k>81)
    {
        cout<<SCORE<<endl;
  if (SCORE>best) best=SCORE;
        return;
    }

    int c,minnum=INT_MAX;
    for (int i=R[0];i!=0;i=R[i])
    {
        if (!S[i]) return;
        if (S[i]<minnum)
        {
            minnum=S[i];
            c=i;
        }
    }

    Remove(c);
    for (int i=D[c];i!=c;i=D[i])
    {
        int tmp=nRow[i];
        SCORE=SCORE+(tmp%10)*(score[tmp/100][(tmp/10)%10]);
        for (int j=R[i];j!=i;j=R[j])
            Remove(nCol[j]);
        dfs(k+1);
        SCORE=SCORE-(tmp%10)*(score[tmp/100][(tmp/10)%10]);
        for (int j=L[i];j!=i;j=L[j])
            Resume(nCol[j]);
    }
    Resume(c);
}

 

int main()
{
         int blanks;
         out_stream.open("d:\\c++\\数独12\\question\\question474.txt");
   cout<<"请输入blanks值"<<endl;
         cin>>blanks;
         CSudoku (blanks);
   for(int i=1;i<=9;i++)
    for(int j=1;j<=9;j++)
     map[i][j]=map_exchange[i-1][j-1];
         display();
         resolve(ALL);
         out_stream.close();

     freopen("d:\\c++\\数独12\\question\\question475.txt","w",stdout);
        /*for(int i=1;i<=9;i++)
   for(int j=1;j<=9;j++)
    map[i][j]=data1[i-1][j-1];*/
        for (int i=0;i<=81*4;i++)
        {
            S[i]=0;
            L[i]=i-1; R[i]=i+1;
            U[i]=D[i]=i;
            nCol[i]=0;
        }
        L[0]=81*4; R[81*4]=0;
        cnt=81*4;
        for (int i=1;i<=9;i++)
            for (int j=1;j<=9;j++)
            {
                if (map[i][j])
                {
                    int k=map[i][j];
                    for (int u=1;u<=4;u++)
                    {
                        L[cnt+u]=cnt+u-1;
                        R[cnt+u]=cnt+u+1;
                        nRow[cnt+u]=100*i+10*j+k;
                    }
                    L[cnt+1]=cnt+4; R[cnt+4]=cnt+1;
                    head[i][j][k]=cnt+1;
                    Ins_node((i-1)*9+j,cnt+1);
                    Ins_node(81+(i-1)*9+k,cnt+2);
                    Ins_node(81*2+(j-1)*9+k,cnt+3);
                    Ins_node(81*3+(subgrid(i,j)-1)*9+k,cnt+4);
                    cnt+=4;
                }
                else
                    for (int k=1;k<=9;k++)
                    {
                        for (int u=1;u<=4;u++)
                        {
                            L[cnt+u]=cnt+u-1;
                            R[cnt+u]=cnt+u+1;
                            nRow[cnt+u]=100*i+10*j+k;
                        }
                        L[cnt+1]=cnt+4; R[cnt+4]=cnt+1;
                        head[i][j][k]=cnt+1;
                        Ins_node((i-1)*9+j,cnt+1);
                        Ins_node(81+(i-1)*9+k,cnt+2);
                        Ins_node(81*2+(j-1)*9+k,cnt+3);
                        Ins_node(81*3+(subgrid(i,j)-1)*9+k,cnt+4);
                        cnt+=4;
                    }
            }
        int k=0;
        for (int i=1;i<=9;i++)
            for (int j=1;j<=9;j++)
                if (map[i][j])
                {
                    k++;
                    SCORE+=(map[i][j])*score[i][j];
                    Remove(nCol[head[i][j][map[i][j]]]);
                    for (int u=R[head[i][j][map[i][j]]];u!=head[i][j][map[i][j]];u=R[u])
                        Remove(nCol[u]);
                }
        dfs(k+1);
        printf("%d\n",best);
        fclose(stdout);
        system("pause");
}

 

 

 

 

for_every_one
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【NOIP2009】靶形数独 DLX（Dancing Links）
辗转山河弋流歌
10-30 2146
[NOIP2009]靶形数独 T4 Time Limit: 2 Sec  Memory Limit: 128 MB Description 　　小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他们想用数独来一比高低。但普通的数独对他们来说都过于简单了，于是他们向Z 博士请教，Z 博士拿出了他最近发明的“靶形数独”，作为这两个孩子比试的题目。 　　靶形数
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解9*9数独 数组模拟双向十字链表
for_every_one的专栏
09-22 3443
QQ 1423173783   EMAIL:1423173783@qq,com  欢迎提出不同意见。 // 本代码用DLX算法解决9*9数独，特点是覆盖了前81列，战斗就解决了，把战斗浓缩在前81列。缺点是用了new 调试不方便，new的数组不好观测 //解题填空顺序存储在O[]中      舞池本来应该用双向十字链表做材料，本代码用二维数组模拟 #include #include #i
数独问题——DLX算法
a_forever_dream的博客
07-15 1015
如果还没有看过DLX算法请点这里~ 题目传送门 回想一下精确覆盖问题，它的要求是每一列恰好有一个1，那么我们可以考虑将每一列作为一个限制条件，那么将数独的限制条件套进去即可。 考虑数独的限制条件： 每一个空只能填一个数（这不是废话吗。。） 每一行中不能出现重复的数字，而且只能填1~9 每一列中不能出现重复的数字，而且只能填1~9 每一个宫中不能出现重复的数字，而且只能填1~9 这样看好像不是很...
POJ 3076 数独DLX
_rabbit的专栏
05-01 1266
Sudoku Time Limit: 10000MS   Memory Limit: 65536K Total Submissions: 4203   Accepted: 2051 Description A Sudoku grid is a 16x16 grid of cells grouped in sixteen 4x4 squares
JavaFX和DLX算法实现的数独游戏.zip
最新发布
05-26
JavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏....
sudoku-solver:使用DLX算法的快速数独难题求解器:puzzle_piece:
05-07
数独是一种逻辑游戏，玩家需要在9x9的格子中填入数字1到9，使得每一行、每一列以及每个3x3的小宫格内的数字都不重复。这个游戏的目标是找到唯一解，因此，数独解算器的任务就是找到满足这些条件的数字填充方式。 接...
基于JavaFX和DLX算法实现的数独游戏，可快速生成和解出数独.zip
05-13
通过基础解法出数只需一种解法，摒除法或唯余法，超出此范围而需要施加进阶解法时，解题点需要进阶解法协助基础解法来满足隐性唯一或显性唯一才能出数，该解题点的解法需要多个步骤协力完成，因此称做组合解法 ...
DLX.zip_DLX
09-22
标题中的"DLX.zip_DLX"暗示我们关注的是一个与DLX算法相关的压缩包文件，而这个算法主要用于解决高...通过分析和学习这些代码，我们可以深入理解DLX算法如何在实际问题中发挥作用，以及如何利用数据结构优化搜索效率。
Java版本的DLX解决数独算法
cggwz的信息飞船
01-29 539
DLX又称作精确覆盖问题，而今天要说的就是把解数独这个问题转化为一个精确覆盖问题，然后来解决它。 其实这是一个很好的解决问题的思路，很多问题都可以转化为一个精确覆盖问题，然后用接下来这个算法来解决它。 关于DLX的思想，网上有不少的解释，这里我就不再赘述，我会在我的另一篇博客里讲解原理。 首先是整个代码的结构。 总共分为四个类，分别是： 主类（StartPoint） 转换器类（Transfer）...
uva 1309 数独【DLX】
ACMer不要报考高校代码为13627的移通学院！
08-16 512
dancing link,数独，uva 1309
DLX之数独问题的解决
heyker的专栏
03-29 878
<br />数独是一个非常经典的智力游戏。它的游戏的规则是这样的：在一个9x9的方格中，你需要把数字1-9填写到空格当中，并且使方格的每一行和每一列中都包含1-9这九个数字。同时还要保证，空格中用粗线划分成9个3x3的方格也同时包含1-9这九个数字。<br />如下例题：<br /><br />其解为：<br /><br /><br />在计算科学理论中，这一类问题的解答被称之为NPC问题中的Hitting Set Problem，中文名应该叫做碰集问题。该类问题可以通过转换成为精确覆盖问题，其中以行表示概
UVA 1469 Sudoku Extension【加强版数独 DLX】
ACMer不要报考高校代码为13627的移通学院！
08-17 405
大多数参照我写的上一篇博客，这次多了一些条件 对于0~9的情况，处理方法几乎一样。 对于O,处理方法则略加修改，相当于只能填写2468 E则为13579 对于其他字母，则构建新一些列，表示【A字母，写1，A字母是2，A字母是3 …… Z字母是1，Z字母是2，Z字母是3】 然后把这些列对应上去，直接跑DLX就能AC了。 #include #inc
poj 3074 Sudoku dlx解数独
sepNINE的专栏
04-27 1478
分析： dlx是从数据结构角度优化01矩阵精确覆盖和重复覆盖的数据结构，它用十字链表只存贮矩阵中的非0元，而01矩阵精确覆盖dfs过程中矩阵会越来越稀疏而且每次恢复现场会浪费大量时间，dlx恰好能解决这两个问题。本题关键是将数独问题转化为01矩阵精确覆盖。数独转化为精确覆盖问题的方法还是参照Knuth的论文，如果读取到一个格子是空的，那么加9行，分别表示这个格子填1到9这9个数字，如果读取到的格
完成数独的算法 python_一个利用DLX算法的Python解数独程序
weixin_39591720的博客
12-18 316
源程序sudokusolver.py#!/usr/bin/env python# Copyright (C) 2012 Daogan Ao # Permission is hereby granted, free of charge, to any person obtaining a copy# of this software and associated documentation file...
舞蹈链，DLX算法详解，OJ精讲，详细代码
EQUINOX1的博客
01-11 1289
如何将实际问题抽象为精确覆盖问题？
DLX算法求解数独
BIT-1120161967的博客
04-16 2851
首先，DLX算法并不是为了解数独而提出的，它是为了解决精确覆盖问题而被提出的。精确覆盖问题：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1。数独这个问题恰好拟合了DLX算法的模型，所以可以用该方法求解。DLX算法的具体分析请看跳跃的舞者，舞蹈链（Dancing Links）算法——求解精确覆盖问题。该帖讲述的十分详细，就不在这里赘述算法的本身了。DLX算法实质...
数独求解 DFS && DLX
weixin_30780221的博客
03-23 147
题目：Sudoku 题意：求解数独。从样例和结果来看应该是简单难度的数独 思路：DFS 　　　设置3个数组，row[i][j] 判断第i行是否放了j数字，col[i][j] 判断第i列是否放了j数字。square[i/3][j/3][x]判断第i/3行第j/3列个宫是否放置了x数字； #include <iostream> #include <algori...
【位运算DFS/DLX】【HDU1426】【数独】
weixin_34358092的博客
03-30 132
题意：标准的一道数独题 DFS做法： 将横纵九宫格里的数字用位运算状态压缩，且可以通过逻辑或来确定总共有哪些数字被选择了，很方便也很快，代码如下 #include <cstdio> #include <cstdlib> #include <cmath> #include <cstring> #include <ctime&...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值