舞蹈链（Dancing Links）求解数独

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

讲解（写的太好了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 int mod = 1e9 + 7;
const int K = 3;//宫的大小
const int N = 9;//每行多少数即3 * 3
const int MAXN = N * N * N + 10;
const int MAXM = N * N * 4 + 10;
const int maxnode = MAXN * 4 + MAXM + 10;
char g[MAXN];

struct DLX {
    int n, m, siz;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[MAXN], S[MAXM];
    int ansd, ans[MAXN];
    void init(int _n, int _m) {
        n = _n;
        m = _m;
        for(int i = 0; i <= m; ++i) {
            S[i] = 0;
            U[i] = D[i] = i;
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;
        siz = m;
        for(int i = 1; i <= n; ++i) H[i] = -1;
    }
    void Link(int r, int c) {
        ++S[Col[++siz] = c];
        Row[siz] = r;
        D[siz] = D[c];
        U[D[c]] = siz;
        U[siz] = c;
        D[c] = siz;
        if(H[r] < 0) H[r] = L[siz] = R[siz] = siz;
        else {
            R[siz] = R[H[r]];
            L[R[H[r]]] = siz;
            L[siz] = H[r];
            R[H[r]] = siz;
        }
    }
    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) {
        for(int i = U[c]; i != c; i = U[i])
            for(int j = L[i]; j != i; j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }
    bool Dance(int d) {
        if(R[0] == 0) {
            for(int i = 0; i < d; ++i) g[(ans[i] - 1) / N] = (ans[i] - 1) % N + '1';    ///输出的数字
            for(int i = 0; i < N * N; ++i) printf("%c", g[i]);
            printf("\n");
            return 1;
        }
        int c = R[0];
        for(int i = R[0]; i != 0; i = R[i])
            if(S[i] < S[c]) c = i;
        remove(c);
        for(int i = D[c]; i != c; i = D[i]) {
            ans[d] = Row[i];
            for(int j = R[i]; j != i; j = R[j]) remove(Col[j]);
            if(Dance(d + 1)) return 1;
            for(int j = L[i]; j != i; j = L[j]) resume(Col[j]);
        }
        resume(c);
        return 0;
    }
};

void place(int &r, int &c1, int &c2, int &c3, int &c4, int i, int j, int k) {
    r = (i * N + j) * N + k;
    c1 = i * N + j + 1;
    c2 = N * N + i * N + k;
    c3 = N * N * 2 + j * N + k;
    c4 = N * N * 3 + ((i / K) * K + (j / K)) * N + k;
}

DLX dlx;

int main() {
    while(~scanf("%s", g)) {
        if(strcmp(g, "end") == 0) break;
        dlx.init(N * N * N, N * N * 4);
        int r, c1, c2, c3, c4;
        for(int i = 0; i < N; ++i) {
            for(int j = 0; j < N; ++j) {
                for(int k = 1; k <= N; ++k) {
                    ///根据题目给出的具体形式改动
                    if(g[i * N + j] == '.' || g[i * N + j] == '0' + k) {
                        place(r, c1, c2, c3, c4, i, j, k);
                        dlx.Link(r, c1);
                        dlx.Link(r, c2);
                        dlx.Link(r, c3);
                        dlx.Link(r, c4);
                    }
                }
            }
        }
        dlx.Dance(0);
    }
    return 0;
}

ZOJ - 3122（4 * 4）

题意：求4 * 4 * 4的数独

（题目中的样例不对，以下是正确样例，注意每两个数独之间输出换行，最后一个数独不用额外换行

--A----C-----O-I
-J--A-B-P-CGF-H-
--D--F-I-E----P-
-G-EL-H----M-J--
----E----C--G---
-I--K-GA-B---E-J
D-GP--J-F----A--
-E---C-B--DP--O-
E--F-M--D--L-K-A
-C--------O-I-L-
H-P-C--F-A--B---
---G-OD---J----H
K---J----H-A-P-L
--B--P--E--K--A-
-H--B--K--FI-C--
--F---C--D--H-N-
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int K = 4;//宫的大小
const int N = 16;//每行多少数即4*4
const int MAXN = N * N * N + 10;
const int MAXM = N * N * 4 + 10;
const int maxnode = MAXN * 4 + MAXM + 10;
char g[MAXN];

struct DLX {
    int n, m, siz;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[MAXN], S[MAXM];
    int ansd, ans[MAXN];
    void init(int _n, int _m) {
        n = _n;
        m = _m;
        for(int i = 0; i <= m; ++i) {
            S[i] = 0;
            U[i] = D[i] = i;
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;
        siz = m;
        for(int i = 1; i <= n; ++i) H[i] = -1;
    }
    void Link(int r, int c) {
        ++S[Col[++siz] = c];
        Row[siz] = r;
        D[siz] = D[c];
        U[D[c]] = siz;
        U[siz] = c;
        D[c] = siz;
        if(H[r] < 0) H[r] = L[siz] = R[siz] = siz;
        else {
            R[siz] = R[H[r]];
            L[R[H[r]]] = siz;
            L[siz] = H[r];
            R[H[r]] = siz;
        }
    }
    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) {
        for(int i = U[c]; i != c; i = U[i])
            for(int j = L[i]; j != i; j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }
    bool Dance(int d) {
        if(R[0] == 0) {
            for(int i = 0; i < d; ++i) g[(ans[i] - 1) / N] = (ans[i] - 1) % N + 'A';    ///输出的数字
            for(int i = 0; i < N * N; ++i) {
                if(i && i % N == 0) printf("\n");
                printf("%c", g[i]);
            }
            printf("\n");
            return 1;
        }
        int c = R[0];
        for(int i = R[0]; i != 0; i = R[i])
            if(S[i] < S[c]) c = i;
        remove(c);
        for(int i = D[c]; i != c; i = D[i]) {
            ans[d] = Row[i];
            for(int j = R[i]; j != i; j = R[j]) remove(Col[j]);
            if(Dance(d + 1)) return 1;
            for(int j = L[i]; j != i; j = L[j]) resume(Col[j]);
        }
        resume(c);
        return 0;
    }
};

void place(int &r, int &c1, int &c2, int &c3, int &c4, int i, int j, int k) {
    r = (i * N + j) * N + k;
    c1 = i * N + j + 1;
    c2 = N * N + i * N + k;
    c3 = N * N * 2 + j * N + k;
    c4 = N * N * 3 + ((i / K) * K + (j / K)) * N + k;
}

DLX dlx;

int main() {
    bool flag = 0;
    while(~scanf("%s", g)) {
        if(flag) printf("\n");
        flag = 1;
        for(int i = 1; i < N; ++i) scanf("%s", g + i * N);
        dlx.init(N * N * N, N * N * 4);
        int r, c1, c2, c3, c4;
        for(int i = 0; i < N; ++i) {
            for(int j = 0; j < N; ++j) {
                for(int k = 1; k <= N; ++k) {
                    ///根据题目给出的具体形式改动
                    if(g[i * N + j] == '-' || g[i * N + j] == 'A' + k - 1) {
                        place(r, c1, c2, c3, c4, i, j, k);
                        dlx.Link(r, c1);
                        dlx.Link(r, c2);
                        dlx.Link(r, c3);
                        dlx.Link(r, c4);
                    }
                }
            }
        }
        dlx.Dance(0);
    }
    return 0;
}

/*
--A----C-----O-I
-J--A-B-P-CGF-H-
--D--F-I-E----P-
-G-EL-H----M-J--
----E----C--G---
-I--K-GA-B---E-J
D-GP--J-F----A--
-E---C-B--DP--O-
E--F-M--D--L-K-A
-C--------O-I-L-
H-P-C--F-A--B---
---G-OD---J----H
K---J----H-A-P-L
--B--P--E--K--A-
-H--B--K--FI-C--
--F---C--D--H-N-
*/

 

XiWenjuan086
关注
专栏目录
夜深人静写算法（五十）- Dancing Links X（跳舞链）
英雄哪里出来
01-31 32万+
双向十字交叉循环链表求解精确覆盖、重复覆盖。 骨牌覆盖、N皇后问题的高效解法。
用Dancing Links解决数独(Sudoku)问题
weixin_30454481的博客
03-20 452
Dancing Links Dancing Links可以认为是一种数据结构（好像本校面向大二年级开设的数据结构课程中就有它），其实就是一种链表，准确地讲是十字双向循环链表。 十字：普通链表是一条线，而十字链表就是一张网，每个结点不仅有左右邻居，还有上下邻居。 双向：双向是链表中很经典的概念，即每个结点要保存上下左右四个方向的邻居指针。 循环：循环也是比较常见的概念了，即每一行的最左结点的左邻居设...
算法实践——舞蹈链（Dancing Links）算法求解数独
weixin_34099526的博客
07-07 862
在“跳跃的舞者，舞蹈链（Dancing Links）算法——求解精确覆盖问题”一文中介绍了舞蹈链（Dancing Links）算法求解精确覆盖问题。 本文介绍该算法的实际运用，利用舞蹈链（Dancing Links）算法求解数独   在前文中可知，舞蹈链（Dancing Links）算法在求解精确覆盖问题时效率惊人。 那利用舞蹈链（Dancing Links）算法求解数独问题，实际上就是下...
python舞蹈链数独游戏
bugcat的博客
07-12 1756
数独游戏是一款古老的智力游戏，据说最早可以追溯到中国古代的“河图洛书”，但是真实可查的是在18世纪数学家欧拉等人发明了“拉丁方阵”等成为数独的最早的样子，后来经过日本的改进逐渐成为现代的数独游戏[1]。数独游戏一共有9×99 \times 99×9个单元格子，在数独游戏当中，玩家需要根据已有的数字去推理出所有的剩余空格的数字，并且要保证 9×99 \times 99×9的单位格子中每一行、每一列以及每个3×33 \times 33×3的九宫格内的数字不重复。数独游戏在开始的适合叫做初盘（如图1(a)所展示）
跳跃的舞者，舞蹈链（Dancing Links）算法——求解精确覆盖问题
weixin_33843409的博客
06-30 817
精确覆盖问题的定义：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1 例如：如下的矩阵 就包含了这样一个集合（第1、4、5行）   如何利用给定的矩阵求出相应的行的集合呢？我们采用回溯法   矩阵1：   先假定选择第1行，如下所示： 如上图中所示，红色的那行是选中的一行，这一行中有3个1，分别是第3、5、6列。 由于这3列已经包含了...
求解数独-舞蹈链求解
janbar的博客
10-28 733
目录前言我的代码代码讲解运行结果舞蹈链求解数独总结前言 数独这个游戏很适合锻炼大脑思考，由于规则很简单，因此很适合我写代码拿来破解。所以就有了这篇随笔了。 首先我想通过自己的思考完成数独的求解，然后再到网上抄答案。提供一个【在线玩数独】的网站。 我的代码 代码讲解     我想通过自己的思路来求解，虽然网上肯定有非常巧妙高效的解法。因此我安装了HoDoKu这个软件，这个软件会分析当前数独每个...
Java实现的Dancing Links算法快速求解数独和n-皇后
资源摘要信息:"Java笔试题算法-dancing-links：Donald Knuth的DancingLinks算法的Java实现。通过示例，包括超快速数独求解器" Donald Knuth是计算机科学领域的大师级人物，他的著作《计算机程序设计艺术》系列是该...
java笔试题算法-dancing-links:Knuth的DancingLinks算法的Java实现。通过示例，包括超快速数独求解器
06-03
Dancing Links 算法的 Java 实现，这是他的算法的快速实现，用于解决精确矩阵覆盖问题。 参见 Knuth 对算法和一些有趣应用的描述。 支持 跳舞链接按原样提供。 如果它坏了，你可以保留两块。 示例用法 一些示例作为...
Dancing Links舞蹈链求解精确覆盖问题（C++代码）
积极的防守者的博客
03-07 632
很多问题（如求解数独等）都可以转化成求解精确覆盖问题，如果能有一个方便的代码求解这个问题是极好的。 于是伟大的前辈们就发明了X算法，利用十字循环链表(dancing link)求解这个问题。 https://blog.csdn.net/whereisherofrom/article/details/79220897 https://www.cnblogs.com/grenet/p/3145800....
基于舞蹈链的数独算法，以Python实现
最新发布
12-26
舞蹈链算法，又称Dancing Links（DLX）算法，是由日本数学家和计算机科学家Donald Knuth提出的一种用于解决完全多归类问题的有效方法。在数独求解中，我们可以将每个空格看作一个“列”，每个可能填入的数字看作一个...
用舞蹈链求解数独问题，将数独问题按特定的规则转化为精确覆盖问题后再进行求解，同时结合数独的特性和人工求解策略对算法进行优化。
06-10
舞蹈链（Dancing Links）是一种高效的精确覆盖求解算法，它能够求解多种复杂的组合问题。将数独问题转化为精确覆盖问题后，利用舞蹈链算法进行求解，可以得到数独问题的正确解。 具体来说，数独问题可以转化为一个...
poj3074 Sudoku--舞蹈链数独
半壶老酒
09-25 955
原题链接：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
舞蹈链数独求解算法
04-10
舞蹈链算法求解数独
Sudoku 数独 （Dancing links）
zhaosdfa
07-06 625
Sudoku Time Limit:1000MS    Memory Limit:65536KB    64bit IO Format:%I64d & %I64u SubmitStatus Description In the game of Sudoku, you are given a large 9 × 9 grid divided into smaller 3
用舞蹈链实现数独2
零昔无浪
03-02 1521
舞蹈链解决数独问题
Dancing-Link+数独版
Luckfort
07-28 453
Dancing-Link ＆＆ Sodoku
舞蹈链解决数独问题
05-31
打开数独程序.cpp 编译运行即可 输入12 12 12显示答案，如果没有显示就是没有结果 输入13 13 13更换数独开局 输入0-8 0-8 0-9在指定位置放值，0表示撤销该位置上的数字。 输入11 11 11检验数独是否正确 自己输入值的时候0表示空位。
[洛谷P1784]-Dancing Links解数独
泉華子的OI足迹
12-07 977
说在前面指针实现有时候确实还挺不方便的… 数组实现的时候，下标既可以代表值，还可以代表位置 然而指针只能指向地址，要么多一次访问，要么单独开一个域来存= = 怎么想指针都不优啊… 然而实际测试出来还是很快的，至少没有被暴力踩hhhhh写这个舞蹈链，从上午8点写到下午4点过，从自己YY到后面不得不参考别人的程序… 因为实现比较复杂，为了让程序变得更「通用」，篡改了原算法的一个小地方，写到后面
用Dancing Links求解数独
QC的博客
07-23 2525
算法实践——舞蹈链（Dancing Links）算法求解数独
POJ 3074,3076,2676 数独 Dancing Links舞蹈链
liwei的专栏
08-29 1319
思路：数独正好是精确覆盖问题的最好例子，这个也算是舞蹈链的模板了吧。 这个和网络流一样，难的是建模。如果能想好怎么建立矩阵的话，那一切都容易了。 这题怎么建矩阵，可以看论文：http://www.cnblogs.com/steady/archive/2011/03/15/1984791.html #pragma comment(linker, "/STACK:1024000000,10240
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值