poj3074 9*9数独，poj3076 16*16数独 DLX

最新推荐文章于 2020-08-22 16:47:57 发布
最新推荐文章于 2020-08-22 16:47:57 发布
阅读量1.1k 收藏
点赞数
分类专栏： DLX
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/night_raven/article/details/19134997
版权

     两题类似，都是求数独，用DLX解数独最大的问题就是建表..对9*9的数独，建立的是（9*9*9）*（9*9*4）的01矩阵去做的。行表示9*9个格子中，每个格子的9种填法，列的话，得有个9*9表示数字放在第i行第j列，第二个9*9表示在第i行放的数是j，第三个9*9表示在第i列放的数是j，第四个9*9表示在第i个九宫格放的数是j.读取数据的时候，如果某个位置上有数字的话，那么添加一行就可以了(已有的数可以看做这个位置只有这一种选择)，如果某个位置是空，那么就添加9行，表示1--9的9种填法，建好表以后直接跑一遍DLX就可以了。16*16的数独也是同样的做法。

poj3074

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=1000*1000;
const int inf=(1<<29);
const int ct[]={1,82,163,244};

int n,m;
int S[1010],st[1010];
int L[maxn],R[maxn],U[maxn],D[maxn];
int col[maxn],row[maxn];
struct ANS
{
    int r,c,k;
}ans[maxn];
int M,K;
char ss[120];
struct DLX
{
    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[col[j]];
            }
        }
    }
    void resume(int c)
    {
        L[R[c]]=c;
        R[L[c]]=c;
        for (int i=U[c]; i!=c; i=U[i])
        {
            for (int j=L[i]; j!=i; j=L[j])
            {
                U[D[j]]=j;
                D[U[j]]=j;
                ++S[col[j]];
            }
        }
    }
    bool dfs(int k)
    {
        if (R[0]==0)
        {
            memset(ss,0,sizeof ss);
            for (int i=0; i<k; i++)
            ss[ans[st[i]].r*9+ans[st[i]].c]=ans[st[i]].k+'0';
            puts(ss);
            return true;
        }
        int ts=inf,c=R[0];
        for (int i=R[c]; i!=0; i=R[i])
        if (S[c]>S[i]) c=i;

        remove(c);
        for (int i=D[c]; i!=c; i=D[i])
        {
            st[k]=row[i];
            for (int j=R[i]; j!=i; j=R[j]) remove(col[j]);
            if (dfs(k+1)) return true;
            for (int j=L[i]; j!=i; j=L[j]) resume(col[j]);
        }
        resume(c);
        return false;
    }

    void init(int m)
    {

        for (int i=1; i<=m; i++)
        {
            L[i]=i-1;
            R[i]=i+1;
            U[i]=D[i]=i;
            col[i]=i;
            row[i]=0;
            S[i]=0;
        }
        L[0]=m;
        R[0]=1;
        U[0]=D[0]=0;
        R[m]=0;

        K=m;
        M=0;
    }
    int makehead(int c)
    {
        K++;
        S[c]++;
        col[K]=c;
        row[K]=M;
        L[K]=R[K]=K;

        U[K]=c;
        D[K]=D[c];
        U[D[K]]=K;
        D[U[K]]=K;
        return K;
    }
    void addcol(int id,int c)
    {
        K++;
        S[c]++;
        col[K]=c;
        row[K]=M;

        L[K]=id;
        R[K]=R[id];
        L[R[K]]=R[L[K]]=K;

        U[K]=c;
        D[K]=D[c];
        U[D[K]]=D[U[K]]=K;
    }

    void addrow(int i,int j,int k)
    {
       int id;
       M++;
       ans[M].r=i;
       ans[M].c=j;
       ans[M].k=k+1;
       id=makehead(9*i+j+ct[0]);
       addcol(id,9*i+k+ct[1]);
       addcol(id,9*j+k+ct[2]);
       addcol(id,(i/3*3+j/3)*9+k+ct[3]);
    }
}dlx;
char rs[200];
int main()
{
//    freopen("in.txt","r",stdin);
    while(gets(rs))
    {
        if (rs[0]=='e') break;
        dlx.init(9*9*4);
        for (int i=0; i<9; i++)
         for (int j=0; j<9; j++)
         {
             if (rs[i*9+j]=='.')
             {
                for (int k=0; k<9; k++)
                dlx.addrow(i,j,k);
             }
             else
             {
                dlx.addrow(i,j,rs[i*9+j]-'1');
             }
         }
         dlx.dfs(0);


    }
    return 0;
}


poj3076

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=3000*3000;
const int inf=(1<<29);
const int ct[]={1,16*16+1,16*16*2+1,16*16*3+1};

int n,m;
int S[16*16*16],st[16*16*16];
int L[maxn],R[maxn],U[maxn],D[maxn];
int col[maxn],row[maxn];
struct ANS
{
    int r,c,k;
}ans[maxn];
int M,K;
char ss[520];
struct DLX
{
    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[col[j]];
            }
        }
    }
    void resume(int c)
    {
        L[R[c]]=c;
        R[L[c]]=c;
        for (int i=U[c]; i!=c; i=U[i])
        {
            for (int j=L[i]; j!=i; j=L[j])
            {
                U[D[j]]=j;
                D[U[j]]=j;
                ++S[col[j]];
            }
        }
    }
    bool dfs(int k)
    {
        if (R[0]==0)
        {
            memset(ss,0,sizeof ss);
            for (int i=0; i<k; i++)
            ss[ans[st[i]].r*16+ans[st[i]].c]=ans[st[i]].k+'A';
            for (int i=0; i<16; i++)
            {
                for (int j=0; j<16; j++)
                cout<<ss[i*16+j];
                cout<<endl;
            }
            return true;
        }
        int ts=inf,c=R[0];
        for (int i=R[c]; i!=0; i=R[i])
        if (S[c]>S[i]) c=i;

        remove(c);
        for (int i=D[c]; i!=c; i=D[i])
        {
            st[k]=row[i];
            for (int j=R[i]; j!=i; j=R[j]) remove(col[j]);
            if (dfs(k+1)) return true;
            for (int j=L[i]; j!=i; j=L[j]) resume(col[j]);
        }
        resume(c);
        return false;
    }

    void init(int m)
    {

        for (int i=1; i<=m; i++)
        {
            L[i]=i-1;
            R[i]=i+1;
            U[i]=D[i]=i;
            col[i]=i;
            row[i]=0;
            S[i]=0;
        }
        L[0]=m;
        R[0]=1;
        U[0]=D[0]=0;
        R[m]=0;

        K=m;
        M=0;
    }
    int makehead(int c)
    {
        K++;
        S[c]++;
        col[K]=c;
        row[K]=M;
        L[K]=R[K]=K;

        U[K]=c;
        D[K]=D[c];
        U[D[K]]=K;
        D[U[K]]=K;
        return K;
    }
    void addcol(int id,int c)
    {
        K++;
        S[c]++;
        col[K]=c;
        row[K]=M;

        L[K]=id;
        R[K]=R[id];
        L[R[K]]=R[L[K]]=K;

        U[K]=c;
        D[K]=D[c];
        U[D[K]]=D[U[K]]=K;
    }

    void addrow(int i,int j,int k)
    {
       int id;
       M++;
       ans[M].r=i;
       ans[M].c=j;
       ans[M].k=k;
       id=makehead(16*i+j+ct[0]);
       addcol(id,16*i+k+ct[1]);
       addcol(id,16*j+k+ct[2]);
       addcol(id,(i/4*4+j/4)*16+k+ct[3]);
    }
}dlx;
char rs[30][30];
int main()
{
//    freopen("in.txt","r",stdin);
    while(cin>>rs[0])
    {
        for (int i=1; i<=15; i++) cin>>rs[i];

        dlx.init(16*16*4);
        for (int i=0; i<16; i++)
         for (int j=0; j<16; j++)
         {
             if (rs[i][j]=='-')
             {
                for (int k=0; k<16; k++)
                dlx.addrow(i,j,k);
             }
             else
             {
                dlx.addrow(i,j,rs[i][j]-'A');
             }
         }
         dlx.dfs(0);
        cout<<endl;

    }
    return 0;
}


NightRaven
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Sudoku16(Solver):这是一个 16*16 谜题的数独解算器-matlab开发
06-01
这是数独（Solver）的增强版，可用于解决 16*16 的难题。 该程序的思想与数独（求解器）相同。 问题通过2个步骤解决步骤 1：使用数独方法 1 在每个方格中，列出所有可能的数字如果只有 1 个可能的数字，这是一个如果在每一行、列或块中，出现一个可能的数字只有一次，这是一个step2：如果一个正方形中只有2个可能的数字尝试每一种，看看哪一种是正确的
poj 3076（DLX）
weixin_33971977的博客
04-05 110
16*16的数独， 跟9*9的类似。。。   Sudoku Time Limit: 10000MS   Memory Limit: 65536K Total Submissions: 3683   Accepted: 1799 Description A Sudoku grid is a 16x16 grid of cel...
POJ 3076 Sudoku
10-05 92
Sudoku Time Limit: 10000MS Memory Limit: 65536K Total Submissions: 4628 Accepted: 2237 Description A Sudoku grid is a 16x16 grid of cells grouped in sixtee...
poj3076(16*16数独)
lch的博客
09-01 1675
转载自：http://blog.csdn.net/lyhypacm/article/details/5923287 题意： 一个16*16的数独问题。 思路： 和poj3024一样，就改点东西。 代码： #include #include #include #include using namespace std; const int oo=0x3f
poj3074 poj3076 数独问题 dancing links
renew
08-02 1019
当初学习dancing links的最大目的就是为了解决数独的问题吧，但是经过这两天的学习之后发现dancing links的功能远不止于此，看来是得多挖掘一下。 当然本文还是介绍解数独的做法。 首先，需要把数度问题转化为一个最小覆盖问题： 1、每个空格最终都会填上一个数，而且有1，2，3，4，5，6，7，8，9这九种可能（介绍3*3的，其他大小的同理），我们可以把每个空格中填写的数字情况看
POJ 2676 代码 搜索数独答案
09-15
简单搜索题 数独 答案 POJ 2676 也可以没事玩玩数独。
POJ.rar_poj java_poj1048
09-24
POJ1048，加强版的约瑟夫问题 难度中等
poj.rar_poj
09-20
POJ 上的近100道水题，基本涵盖了所有基本算法和数据结构，全部AC
POJ.rar_poj
09-19
poj nwpu 2013 年才语言答案，不是全部，仅供参考
POJ 3076
weixin_30360497的博客
08-25 116
DLX算法，刚接触，是关于精确覆盖的，白书上有算法介绍。 代码模板 #include <iostream> #include <cstdio> #include <cstring> #include <algorithm> #include <string.h> #include <vector> usin...
求助：生成一个16*16数独终盘
for_every_one的专栏
10-03 1684
QQ：1423173783    邮箱：1423173783@qq.com 我想在一秒内生成一个16*16数独的终盘。（终盘就是16*16都填满了，又符合每行每列每宫包含1,2，...16这些数） 当然是随机生成，如果构造一个我1ms就能造一个，还能造一堆。就是说随机生成一个终盘（这里不作严格要求：生成的那一个终盘是理论上有可能的任一个）。不需要如此严格的要求。只要1m内能生成一个随机的16*1
POJ 3076 Sudoku (DLX)
= =
11-22 956
16*16 的数独，DLX的最爱 /* Created Time: Thursday, November 21, 2013 PM08:36:56 CST */ #include #include #include #include using namespace std; const int N = 20; const int MAXN = 4*256+7, MAXNODE = 4*25
POJ 3076 Sudoku DLX精确覆盖
码代码的猿猿
10-13 1473
DLX精确覆盖模版题..... Sudoku Time Limit: 10000MS   Memory Limit: 65536K Total Submissions: 4416   Accepted: 2143 Description A Sudoku grid is a 16x16 grid of c
poj 3076 Sudoku
140142
11-12 1222
题意： 给出一个16*16的数独，要求你将其补全； 数据保证给出的数独有且仅有一个解； 题解： 数独毕竟是数独，并不像今年NOIP考的那个幻方那样有构造方案； 显然这种看上去就很难的问题我们只能靠人类智慧或者用力暴搜； 朴素的搜索就是每一个格子试探性的填入每一个数，然后递归进行直到找到一组解或者不能按照规律进行时停止； 而为了解决数独问题，我们可以将其转化成精准覆盖问题来解决
刷题16-数独问题
Awt_FuDongLai的博客
08-22 1374
原题链接 题目描述 数独是一个非常有名的游戏。整个是一个9X9的大宫格，其中又被划分成9个3X3的小宫格。 要求在每个小格中放入1-9中的某个数字。 要求是：每行、每列、每个小宫格中数字不能重复。 现要求用计算机求解数独。 输入描述 输入9行，每行为空格隔开的9个数字，为0的地方就是需要填充的数字。 输出描述 输出九行，每行九个空格隔开的数字，为解出的答案。 示例 输入： 0 9 0 0 0 0 0 6 0 8 0 1 0 0 0 5 0 9 0 5 0 3 0 4 0 7 0 0 0 8 0 7 0
poj2676 2918 3074 3076 Sudoku
KLChen的博客
02-19 176
poj 2676题意：数独思路：1.dancing link2. dfs(填写每一个九宫格) 加剪枝 回溯  排除已出现的数字（ sqr line column）  收缩顺序 优先选取已知数字较多的方块搜索#include &lt;iostream&gt; #include&lt;cstring&gt; #include &lt;cstdio&gt; #define mem(a) memset(a...
POJ - 3076 Sudoku （舞蹈链模板）
LP_Cong
04-27 343
16*16的数独题。网上已经有很多解释了，关于解法推荐博客：https://blog.csdn.net/bl0ss0m/article/details/17918705这里用来保存舞蹈链模板！#include &lt;stdio.h&gt; using namespace std; typedef long long ll; const int MAXN = 16*16*16+10; const ...
poj3076 Sudoku（DFS+剪枝）
A_Bright_CH的博客
08-22 1089
题意 用A~P填写一个16*16的数独。 题解 DFS+超强剪枝 1、搜索每一个位置可以填的数，如果只有一个，立刻填上；如果没有可以填的数，立刻回溯。 2、枚举一个数字，在每个行\列\宫格中，有没有可以填的地方。如果只有一个，将其填上；如果无法填上，立刻回溯。 3、选取一个可能情况最少的格子，枚举其所有情况。 4、dfs(k+1)，重复执行以上操作。 以上1和2的操作是有区别的：1只...
poj-2170 Lattice Animals *****
最新发布
05-13
这是一道比较经典的计数问题。题目描述如下： 给定一个 $n \times n$ 的网格图，其中一些格子被标记为障碍。一个连通块是指一些被标记为障碍的格子的集合，满足这些格子在网格图中连通。一个格子是连通的当且仅当它与另一个被标记为障碍的格子在网格图中有公共边。 现在，你需要计算在这个网格图中，有多少个不同的连通块，满足这个连通块的大小（即包含的格子数）恰好为 $k$。 这是一道比较经典的计数问题，一般可以通过计算生成函数的方法来解决。具体来说，我们可以定义一个生成函数 $F(x)$，其中 $[x^k]F(x)$ 表示大小为 $k$ 的连通块的个数。那么，我们可以考虑如何计算这个生成函数。 对于一个大小为 $k$ 的连通块，我们可以考虑它的形状。具体来说，我们可以考虑以该连通块的最左边、最上边的格子为起点，从上到下、从左到右遍历该连通块，把每个格子在该连通块中的相对位置记录下来。由于该连通块的大小为 $k$，因此这些相对位置一定是 $(x,y) \in [0,n-1]^2$ 中的 $k$ 个不同点。 现在，我们需要考虑如何计算这些点对应的连通块是否合法。具体来说，我们可以考虑从左到右、从上到下依次处理这些点，对于每个点 $(x,y)$，我们需要考虑它是否能够与左边的点和上边的点连通。具体来说，如果 $(x-1,y)$ 和 $(x,y)$ 都在该连通块中且它们在网格图中有公共边，那么它们就是连通的；同样，如果 $(x,y-1)$ 和 $(x,y)$ 都在该连通块中且它们在网格图中有公共边，那么它们也是连通的。如果 $(x,y)$ 与左边和上边的点都不连通，那么说明这个点不属于该连通块。 考虑到每个点最多只有两个方向需要检查，因此时间复杂度为 $O(n^2 k)$。不过，我们可以使用类似于矩阵乘法的思想，将这个过程优化到 $O(k^3)$ 的时间复杂度。 具体来说，我们可以设 $f_{i,j,k}$ 表示状态 $(i,j)$ 所代表的点在连通块中，且连通块的大小为 $k$ 的方案数。显然，对于一个合法的 $(i,j,k)$，我们可以考虑 $(i-1,j,k-1)$ 和 $(i,j-1,k-1)$ 这两个状态，然后把点 $(i,j)$ 加入到它们所代表的连通块中。因此，我们可以设计一个 $O(k^3)$ 的 DP 状态转移，计算 $f_{i,j,k}$。 具体来说，我们可以考虑枚举连通块所包含的最右边和最下边的格子的坐标 $(x,y)$，然后计算 $f_{x,y,k}$。对于一个合法的 $(x,y,k)$，我们可以考虑将 $(x,y)$ 所代表的点加入到 $(x-1,y,k-1)$ 和 $(x,y-1,k-1)$ 所代表的连通块中。不过，这里需要注意一个细节：如果 $(x-1,y)$ 和 $(x,y)$ 在网格图中没有相邻边，那么它们不能算作连通的。因此，我们需要特判这个情况。 最终，$f_{n,n,k}$ 就是大小为 $k$ 的连通块的个数，时间复杂度为 $O(n^2 k + k^3)$。 参考代码：

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值