POJ 3074,3076,2676 数独 Dancing Links舞蹈链

最新推荐文章于 2022-07-12 16:55:44 发布
最新推荐文章于 2022-07-12 16:55:44 发布
阅读量1.3k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011466175/article/details/38927719
版权

POJ 3074 Sudoku

思路：数独正好是精确覆盖问题的最好例子，这个也算是舞蹈链的模板了吧。

这个和网络流一样，难的是建模。如果能想好怎么建立矩阵的话，那一切都容易了。

这题怎么建矩阵，可以看论文：http://www.cnblogs.com/steady/archive/2011/03/15/1984791.html

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define llson j<<1,l,mid
#define rrson j<<1|1,mid+1,r
#define INF 0x7fffffff
#define maxn 1000005
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
int head,sz;
int U[maxn],D[maxn],L[maxn],R[maxn];//上下左右链表指针
int H[maxn],ROW[maxn],C[maxn],S[maxn],O[maxn];
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[C[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])
        {
            ++S[C[j]];
            U[D[j]]=j;
            D[U[j]]=j;
        }
    }
    L[R[c]]=c;
    R[L[c]]=c;
}
void init(int m)//m是列
{
    head=0;//头指针为0
    for(int i=0; i<=m; i++)
    {
        U[i]=i;
        D[i]=i;//建立双向十字链表
        L[i]=i-1;
        R[i]=i+1;
        S[i]=0;
    }
    R[m]=0;
    L[0]=m;
    S[0]=INF+1;
    sz=m+1;
    memset(H,0,sizeof(H));
}
void insert(int i, int j)
{
    if(H[i])
    {
        L[sz] = L[H[i]];
        R[sz] = H[i];
        L[R[sz]] = sz;
        R[L[sz]] = sz;
    }
    else
    {
        L[sz] = sz;
        R[sz] = sz;
        H[i] = sz;
    }
    U[sz] = U[j];
    D[sz] = j;
    U[D[sz]] = sz;
    D[U[sz]] = sz;
    C[sz] = j;
    ROW[sz] = i;
    ++S[j];
    ++sz;
}
bool dfs(int k,int len)
{
    if(R[head]==head)
    {
        sort(O,O+len*len);
        int p=0;
        for(int i=0; i<len; i++)
            for(int j=0; j<len; j++)
            {
                int num=O[p++];
                num=num-(i*len+j)*len;
                printf("%d",num);
            }
        puts("");
        return  true;
    }
    int s=INF,c;
    for (int t=R[head]; t!=head; t=R[t])
        if (S[t]<s) s=S[t],c=t;
    remove(c);
    for(int i=D[c]; i!=c; i=D[i])
    {
        O[k]=ROW[i];
        for(int j=R[i]; j!=i; j=R[j])
            remove(C[j]);
        if(dfs(k+1,len)) return  true;
        for(int j=L[i]; j!=i; j=L[j])
            resume(C[j]);
    }
    resume(c);
    return  false;
}
void calc(int i,int j,int k,int len)
{
    int r=(i*len+j-1)*len+k;
    int base=sqrt(len);
    //第i行有数字k
    insert(r,i*len+k);
    //第j列有数字k
    insert(r,len*len+(j-1)*len+k);
    //第k块有数字k
    int block=(j-1)/base*base+i/base;
    insert(r,len*len*2+block*len+k);
    //第i行j列有一个数字(限制一个出格子只填一个数)
    insert(r,len*len*3+i*len+j);
}
void build(char *s,int len)//len表示是几宫数独
{
    int i,j,k,p=0;
    init(len*len*4);
    for(i=0; i<len; i++)
        for(j=1; j<=len; j++,p++)
        {
            if(s[p]=='.')
                for(k=1; k<=len; k++)
                    calc(i,j,k,len);
            else calc(i,j,s[p]-'0',len);
        }
}
int main()
{
    //freopen("1.txt","r",stdin);
    char s[84];
    while(scanf("%s",s)&&strcmp(s,"end"))
    {
        build(s,9);
        dfs(0,9);//从根开始搜
    }
    return 0;
}

poj 3076 Sudoku

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define llson j<<1,l,mid
#define rrson j<<1|1,mid+1,r
#define INF 0x7fffffff
#define maxn 1000005
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
int head,sz;
int U[maxn],D[maxn],L[maxn],R[maxn];//上下左右链表指针
int H[maxn],ROW[maxn],C[maxn],S[maxn],O[maxn];
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[C[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])
        {
            ++S[C[j]];
            U[D[j]]=j;
            D[U[j]]=j;
        }
    }
    L[R[c]]=c;
    R[L[c]]=c;
}
void init(int m)//m是列
{
    head=0;//头指针为0
    for(int i=0; i<=m; i++)
    {
        U[i]=i;
        D[i]=i;//建立双向十字链表
        L[i]=i-1;
        R[i]=i+1;
        S[i]=0;
    }
    R[m]=0;
    L[0]=m;
    S[0]=INF+1;
    sz=m+1;
    memset(H,0,sizeof(H));
}
void insert(int i, int j)
{
    if(H[i])
    {
        L[sz] = L[H[i]];
        R[sz] = H[i];
        L[R[sz]] = sz;
        R[L[sz]] = sz;
    }
    else
    {
        L[sz] = sz;
        R[sz] = sz;
        H[i] = sz;
    }
    U[sz] = U[j];
    D[sz] = j;
    U[D[sz]] = sz;
    D[U[sz]] = sz;
    C[sz] = j;
    ROW[sz] = i;
    ++S[j];
    ++sz;
}
bool dfs(int k,int len)
{
    if(R[head]==head)
    {
        sort(O,O+len*len);
        int p=0;
        for(int i=0; i<len; i++)
        {
            for(int j=0; j<len; j++)
            {
                int num=O[p++];
                num=num-(i*len+j)*len;
                printf("%c",num+'A'-1);
            }
            puts("");
        }
        puts("");
        return  true;
    }
    int s=INF,c;
    for (int t=R[head]; t!=head; t=R[t])
        if (S[t]<s) s=S[t],c=t;
    remove(c);
    for(int i=D[c]; i!=c; i=D[i])
    {
        O[k]=ROW[i];
        for(int j=R[i]; j!=i; j=R[j])
            remove(C[j]);
        if(dfs(k+1,len))
            return  true;
        for(int j=L[i]; j!=i; j=L[j])
            resume(C[j]);
    }
    resume(c);
    return  false;
}
void calc(int i,int j,int k,int len)
{
    int r=(i*len+j-1)*len+k;
    int base=sqrt(len);
    //第i行有数字k
    insert(r,i*len+k);
    //第j列有数字k
    insert(r,len*len+(j-1)*len+k);
    //第k块有数字k
    int block=(j-1)/base*base+i/base;
    insert(r,len*len*2+block*len+k);
    //第i行j列有一个数字(限制一个出格子只填一个数)
    insert(r,len*len*3+i*len+j);
}
void build(char s[][17],int len)//len表示是几宫数独
{
    int i,j,k;
    init(len*len*4);
    for(i=0; i<len; i++)
        for(j=1; j<=len; j++)
        {
            if(s[i][j-1]=='-')
                for(k=1; k<=len; k++)
                    calc(i,j,k,len);
            else calc(i,j,s[i][j-1]-'A'+1,len);
        }
}
int main()
{
    //freopen("1.txt","r",stdin);
    char s[17][17];
    while(~scanf("%s",s[0]))
    {
        for(int i=1; i<16; i++)
            scanf("%s",s[i]);
        build(s,16);
        dfs(0,16);//从根开始搜
    }
    return 0;
}

POJ 2676 Sudoku 

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define llson j<<1,l,mid
#define rrson j<<1|1,mid+1,r
#define INF 0x7fffffff
#define maxn 1000005
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
int head,sz;
int U[maxn],D[maxn],L[maxn],R[maxn];//上下左右链表指针
int H[maxn],ROW[maxn],C[maxn],S[maxn],O[maxn];
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[C[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])
        {
            ++S[C[j]];
            U[D[j]]=j;
            D[U[j]]=j;
        }
    }
    L[R[c]]=c;
    R[L[c]]=c;
}
void init(int m)//m是列
{
    head=0;//头指针为0
    for(int i=0; i<=m; i++)
    {
        U[i]=i;
        D[i]=i;//建立双向十字链表
        L[i]=i-1;
        R[i]=i+1;
        S[i]=0;
    }
    R[m]=0;
    L[0]=m;
    S[0]=INF+1;
    sz=m+1;
    memset(H,0,sizeof(H));
}
void insert(int i, int j)
{
    if(H[i])
    {
        L[sz] = L[H[i]];
        R[sz] = H[i];
        L[R[sz]] = sz;
        R[L[sz]] = sz;
    }
    else
    {
        L[sz] = sz;
        R[sz] = sz;
        H[i] = sz;
    }
    U[sz] = U[j];
    D[sz] = j;
    U[D[sz]] = sz;
    D[U[sz]] = sz;
    C[sz] = j;
    ROW[sz] = i;
    ++S[j];
    ++sz;
}
bool dfs(int k,int len)
{
    if(R[head]==head)
    {
        sort(O,O+len*len);
        int p=0;
        for(int i=0; i<len; i++)
        {
            for(int j=0; j<len; j++)
            {
                int num=O[p++];
                num=num-(i*len+j)*len;
                printf("%d",num);
            }
            puts("");
        }
        return  true;
    }
    int s=INF,c;
    for (int t=R[head]; t!=head; t=R[t])
        if (S[t]<s) s=S[t],c=t;
    remove(c);
    for(int i=D[c]; i!=c; i=D[i])
    {
        O[k]=ROW[i];
        for(int j=R[i]; j!=i; j=R[j])
            remove(C[j]);
        if(dfs(k+1,len))
            return  true;
        for(int j=L[i]; j!=i; j=L[j])
            resume(C[j]);
    }
    resume(c);
    return  false;
}
void calc(int i,int j,int k,int len)
{
    int r=(i*len+j-1)*len+k;
    int base=sqrt(len);
    //第i行有数字k
    insert(r,i*len+k);
    //第j列有数字k
    insert(r,len*len+(j-1)*len+k);
    //第k块有数字k
    int block=(j-1)/base*base+i/base;
    insert(r,len*len*2+block*len+k);
    //第i行j列有一个数字(限制一个出格子只填一个数)
    insert(r,len*len*3+i*len+j);
}
void build(char s[][10],int len)//len表示是几宫数独
{
    int i,j,k;
    init(len*len*4);
    for(i=0; i<len; i++)
        for(j=1; j<=len; j++)
        {
            if(s[i][j-1]=='0')
                for(k=1; k<=len; k++)
                    calc(i,j,k,len);
            else calc(i,j,s[i][j-1]-'0',len);
        }
}
int main()
{
    //freopen("1.txt","r",stdin);
    int t;
    cin>>t;
    while(t--)
    {
        char s[10][10];
        for(int i=0; i<9; i++)
            scanf("%s",s[i]);
        build(s,9);
        dfs(0,9);//从根开始搜
    }
    return 0;
}

潇洒走一回LW
关注
poj3074/3076 Dancing Links 解数独
10-06 2746
Dancing Links经典应用
poj (3074：数独)Dancing Link算法神模版
Weiguang_123的专栏
09-02 4703
http://www.ocf.berkeley.edu/ jchu/publicportal/sudoku/0011047.pdf 题意：玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。 /* DLX解决9*9的数独问题，转化为729*324的精确覆盖问题 行： 一共9 * 9 * 9 == 729行。一共9 *
舞蹈链数独求解算法
04-10
舞蹈链算法求解数独
跳跃的舞者，舞蹈链（Dancing Links）算法——求解精确覆盖问题
weixin_33843409的博客
06-30 797
精确覆盖问题的定义：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1 例如：如下的矩阵 就包含了这样一个集合（第1、4、5行）   如何利用给定的矩阵求出相应的行的集合呢？我们采用回溯法   矩阵1：   先假定选择第1行，如下所示： 如上图中所示，红色的那行是选中的一行，这一行中有3个1，分别是第3、5、6列。 由于这3列已经包含了...
算法实践——舞蹈链（Dancing Links）算法求解数独
weixin_34099526的博客
07-07 840
在“跳跃的舞者，舞蹈链（Dancing Links）算法——求解精确覆盖问题”一文中介绍了舞蹈链（Dancing Links）算法求解精确覆盖问题。 本文介绍该算法的实际运用，利用舞蹈链（Dancing Links）算法求解数独   在前文中可知，舞蹈链（Dancing Links）算法在求解精确覆盖问题时效率惊人。 那利用舞蹈链（Dancing Links）算法求解数独问题，实际上就是下...
求解数独-舞蹈链求解
janbar的博客
10-28 702
目录前言我的代码代码讲解运行结果舞蹈链求解数独总结前言 数独这个游戏很适合锻炼大脑思考，由于规则很简单，因此很适合我写代码拿来破解。所以就有了这篇随笔了。 首先我想通过自己的思考完成数独的求解，然后再到网上抄答案。提供一个【在线玩数独】的网站。 我的代码 代码讲解     我想通过自己的思路来求解，虽然网上肯定有非常巧妙高效的解法。因此我安装了HoDoKu这个软件，这个软件会分析当前数独每个...
舞蹈链解决数独问题
05-31
打开数独程序.cpp 编译运行即可 输入12 12 12显示答案，如果没有显示就是没有结果 输入13 13 13更换数独开局 输入0-8 0-8 0-9在指定位置放值，0表示撤销该位置上的数字。 输入11 11 11检验数独是否正确 自己输入值的时候0表示空位。
POJ 2676 代码 搜索数独答案
09-15
简单搜索题 数独 答案 POJ 2676 也可以没事玩玩数独。
【POJ 2676】Sudoku数独（DFS）
Chen_yuazzy的博客
07-28 1286
思路：DFS遍历解数独，很有意思的题目，由于行、列、每一个3*3小方格都不能重复，故需要三个数组row,col,dig来标记某1~9数字是否出现。DFS遍历，具体思路见注释。
POJ2676-Sudoku
07-31
标题“POJ2676-Sudoku”指向的是北京大学在线编程平台POJ上的一道题目，编号为2676，题目内容与经典的数独游戏有关。解题报告和AC（Accepted）代码是该问题解决方案的组成部分，通常包括对问题的理解、算法设计、...
poj3076 Sudoku--舞蹈链数独
半壶老酒
09-26 931
原题链接：http://poj.org/problem?id=3076 题意：一个数独模板题，16*16的数独。 #define _CRT_SECURE_NO_DEPRECATE #include #include #include #include #include #include #include #define INF 99999999 #define eps 0.
用舞蹈链解数独问题
零昔无浪
02-23 1527
转载自：http://fayaa.com/code/view/1738/ 把debug文件夹中的exe文件放在指定路径，这里放在F盘 然后打开cmd文件输入 F:\53.exe 030000000010200060000600400004000800007000000000001003000460005000800000050000001 输出结果 数独测试案例 0
poj3074 Sudoku--舞蹈链数独
半壶老酒
09-25 942
原题链接：http://poj.org/problem?id=3074 题意：给定一个9*9的数独，求解。 #define _CRT_SECURE_NO_DEPRECATE #include #include #include #include #include #include #include #define INF 99999999 #define eps 0.000
舞蹈链 —— 9 × 9 数独模板（POJ - 3074）
Scar_Halo
11-15 479
用 324324324 列、 729729729 行构造： 本题出自 ZOJ−3122ZOJ - 3122ZOJ−3122： PS：PS：PS：这里其实还可以优化，对必选行的列进行处理，可以减少行和列 #include&amp;amp;amp;amp;amp;amp;amp;lt;bits/stdc++.h&amp;amp;amp;amp;amp;amp;amp;gt; using namespace std; typedef long long ll; #define N 500010
python舞蹈链数独游戏
bugcat的博客
07-12 1718
数独游戏是一款古老的智力游戏，据说最早可以追溯到中国古代的“河图洛书”，但是真实可查的是在18世纪数学家欧拉等人发明了“拉丁方阵”等成为数独的最早的样子，后来经过日本的改进逐渐成为现代的数独游戏[1]。数独游戏一共有9×99 \times 99×9个单元格子，在数独游戏当中，玩家需要根据已有的数字去推理出所有的剩余空格的数字，并且要保证 9×99 \times 99×9的单位格子中每一行、每一列以及每个3×33 \times 33×3的九宫格内的数字不重复。数独游戏在开始的适合叫做初盘（如图1(a)所展示）
用Dancing Links求解数独
QC的博客
07-23 2506
算法实践——舞蹈链（Dancing Links）算法求解数独
舞蹈链算法与数独求解
duanhy的专栏
03-11 5558
舞蹈链算法与数独求解 舞蹈链算法 舞蹈链算法用于求解精确覆盖问题 。 精确覆盖问题可以理解为如下问题： 给定一个01矩阵，寻找一个行的集合，使得集合中的列恰好满足每一列包含一个1。
舞蹈链
cj1064789374的博客
12-16 242
舞蹈链
舞蹈链（Dancing Links）求解数独
。
03-24 382
讲解（写的太好了orz POJ - 3074（3 * 3） 题意：求3 * 3 * 3大小的数独 #include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> using namespace std; typedef long long ll; const int inf = 0x3f3f3f3f; const
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值