【笔记】DLX算法及常见应用

最新推荐文章于 2022-06-24 12:37:59 发布
最新推荐文章于 2022-06-24 12:37:59 发布
阅读量349 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/greenty1208/p/9898516.html
版权

参考资料

精确覆盖问题讲解——grenet

数独模型转换——bl0ss0m

DLX算法求解数独——grenet

问题引入

精确覆盖问题：

有ｒ个由１～ｎ组成的集合S1,S2,S3....Sr,要求选择若干集合，使得１～ｎ恰好只在一个集合里出现。

数独问题：

在９×９的矩阵里填数，使得每一行每一列每一个九宫格里１～９都恰好出现一次

解法分析

先考虑精确覆盖问题，我们将其建成一个ｒ×ｎ的０１矩阵，第ｉ行第ｊ列为１表示第ｉ个集合里有元素ｊ，那选择若干集合就转化为选择若干行

一种很直观的想法是进行回溯深搜——每当选中一行，则将该行以及该行为１的列都删掉，这样就得到了一个更小的矩阵，回溯的时候将删掉的行加回来

这个算法我们称之为Ｘ算法，在求解的过程中有大量的缓存矩阵和回溯矩阵的过程，如何缓存矩阵以及相关的数据（保证后面的回溯能正确恢复数据）比较复杂低效。

于是有神犇想了一种数据结构来维护这种删除和插入的操作——提到高效插入和删除，可以想到链表吧。

ＤＬＸ就是一种用了双向链表思想来维护矩阵的数据结构

模型

ＤＬＸ用的数据结构是交叉十字循环双向链，每个元素不仅是横向循环双向链中的一份子，又是纵向循环双向链的一份子因为精确覆盖问题的矩阵往往是稀疏矩阵（矩阵中，0的个数多于1），ＤＬＸ仅仅记录矩阵中值是1的元素。

每个元素有6个分量：

　　Left指向左边的元素、Right指向右边的元素、Up指向上边的元素、Down指向下边的元素、Col指向列标元素、Row指示当前元素所在的行

一些辅助元素：

Ans（）：Ans数组，在求解的过程中保留当前的答案，以供最后输出答案用。

Head元素：求解的辅助元素，在求解的过程中，当判断出Head.Right=Head（也可以是Head.Left=Head）时，求解结束，输出答案。Head元素只有两个分量有用。其余的分量对求解没啥用

C元素：列标元素，每列有一个列标元素。本文开始的题目的列标元素分别是C1、C2、C3、C4、C5、C6、C7。每一列的元素的Col分量都指向所在列的列标元素。列标元素的Col分量指向自己（也可以是没有）。在初始化的状态下，Head.Right=C1、C1.Right=C2、……、C7.Right=Head、Head.Left=C7等等。列标元素的分量Row=0，表示是处在第0行。

结构体框架

#define FOR(i,A,s) for(int i = A[s]; i != s; i = A[i])

 

struct DLX {
  //成员变量
  int n, sz; // 列数，结点总数
  int S[MAXC]; // 各列结点数
  int row[MAXN], col[MAXN]; // 各结点行列编号
  int L[MAXN], R[MAXN], U[MAXN], D[MAXN]; // 十字链表
  vector<int>vec;
  int ansd, ans[MAXR]; // 解

  //成员函数
  void init(int n);//n为列数
  void remove(int c); 
  void restore(int c);
  bool dfs(int d);//d为递归深度
  bool solve();

  //数独所需函数
  void build();
  void decode(int code,int &a,int &b,int &c);
  inline int encode(int a,int b,int c);
  void output();
  void addRow(int r);
  inline int trans(int x,int y);

};

各部分实现

void init

建立头结点，列标元素，横向成环，纵向成环（指向自己）,初始化各变量

void DLX::init(int n) { // n是列数
    this->n = n;
    for(int i = 0 ; i <= n; i++) {
      U[i] = i; D[i] = i; L[i] = i-1, R[i] = i+1;
    }
    R[n] = 0; L[0] = n;
    sz = n + 1;
    memset(S, 0, sizeof(S));
}

bool solve

解决精确覆盖问题的接口，如果有解返回true,无解返回false

bool DLX::solve() {
    f(!dfs(0)) return false;
    return true;
}

 

bool dfs

如果找到解（R[0] == 0 ) 则记录解的长度并返回

否则继续深搜下去，搜不到答案则返回false

bool DLX::dfs(int d) {
    if (R[0] == 0) { // 找到解
      ansd = d; // 记录解的长度
      return true;
    }
    // 找S最小的列c
    int c = R[0]; // 第一个未删除的列
    FOR(i,R,0) if(S[i] < S[c]) c = i;
    remove(c); // 删除第c列
    FOR(i,D,c) { // 用结点i所在行覆盖第c列
      ans[d] = row[i];
      FOR(j,R,i) remove(col[j]); // 删除结点i所在行能覆盖的所有其他列
      if(dfs(d+1)) return true;
      FOR(j,L,i) restore(col[j]); // 恢复结点i所在行能覆盖的所有其他列
    }
    restore(c); // 恢复第c列
    return false;
}

void remove

删除第ｃ列

void DLX::remove(int c) {
    L[R[c]] = L[c];
    R[L[c]] = R[c];
    FOR(i,D,c)
      FOR(j,R,i) { U[D[j]] = U[j]; D[U[j]] = D[j]; --S[col[j]]; }
}

 

void restore

恢复第ｃ列

void DLX::restore(int c) {
    FOR(i,U,c) FOR(j,L,i) { ++S[col[j]]; U[D[j]] = j; D[U[j]] = j; }
    L[R[c]] = c;R[L[c]] = c;
}

 void addRow

增加一行

void DLX::addRow(int r) {
    int first = sz;
    for(int i = 0; i < vec.size(); i++) {
      int c = vec[i];
    //    cout<<c<<" ";
      L[sz] = sz - 1; R[sz] = sz + 1; D[sz] = c; U[sz] = U[c];
      D[U[c]] = sz; U[c] = sz;
      row[sz] = r; col[sz] = c;
      S[c]++; sz++;
    }
    //    cout<<endl;
    R[sz - 1] = first; L[first] = sz - 1;
}

 

数独问题

1、把数独问题转换为精确覆盖问题

2、设计出数据矩阵

3、用舞蹈链（Dancing Links）算法求解该精确覆盖问题

4、把该精确覆盖问题的解转换为数独的解

首先看看数独问题（9*9的方格）的规则

1、每个格子只能填一个数字

2、每行每个数字只能填一遍

3、每列每个数字只能填一遍

4、每宫每个数字只能填一遍

把上面的表述换个说法

1、每个格子只能填一个数字

2、每行1-9的这9个数字都得填一遍（也就意味着每个数字只能填一遍）

3、每列1-9的这9个数字都得填一遍

4、每宫1-9的这9个数字都得填一遍

 那么我们现在将９×９数独问题转换成一个324列的精确覆盖问题：

4个限制条件，将其分别转换为81列

每个格子都要填入数字
　　1到81列，表示数独中9*9=81个格子是否填入了数字。如果是，则选取的01行在该01列上为1

每一行都要有1~9填入
　　81+1到81*2列，每9列就代表数独中的一行，如果该行有某个数字，则其对应的列上为1

每一列都要有1~9填入
　　81*2+1到81*3列，每9列就代表数独中的一列

每一宫都要有1~9填入
　　81*3+1到81*4列，每9列就代表数独中的一宫！

建好模型后跑ＤＬＸ算法即可求解

void DLX::build() {
  for(int i=0;i<9;i++) {
      for(int j=0;j<9;j++) {
    for(int k=0;k<9;k++){
        if(sudoku[i][j]==-1||sudoku[i][j]==k){
        //cout<<i<<" "<<j<<" "<<k<<endl;
        vec.clear();
        vec.push_back(encode(0,i,j));
        vec.push_back(encode(1,i,k));
        vec.push_back(encode(2,j,k));
        vec.push_back(encode(3,trans(i,j),k));            
        addRow(encode(i,j,k));
        }
    }
      }
  }
  return;
}


inline int DLX::encode(int a,int b,int c){
  return 81*a + b*9+c+1;
}


void DLX::decode(int code,int &a,int &b,int &c){
  code--;
  c = code%9;code/=9;
  b = code%9;code/=9;
  a = code;
}

inline int DLX::trans(int x,int y){
  x = x/3;
  y = y/3;
  return x*3+y;
}

void DLX::output() {
  for(int i=0;i<ansd;i++){
      int r,c,v;
      decode(ans[i],r,c,v);
      sudoku[r][c]=v;
  }
  for(int i=0;i<9;i++){
      for(int j=0;j<9;j++){
      printf("%d",sudoku[i][j]+1);
      }
      putchar('\n');
  }
}

 

贴一下模板题poj2676的代码

#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
using namespace std;

int _;
int sudoku[10][10];
const int MAXN = 81*4*81+10,MAXR = 9*9*9+10,MAXC = 81*4+10;
// 行编号从1开始，列编号为1~n，结点0是表头结点; 结点1~n是各列顶部的虚拟结点
struct DLX {
  //成员变量
  int n, sz; // 列数，结点总数
  int S[MAXC]; // 各列结点数
  int row[MAXN], col[MAXN]; // 各结点行列编号
  int L[MAXN], R[MAXN], U[MAXN], D[MAXN]; // 十字链表
  vector<int>vec;
  int ansd, ans[MAXR]; // 解

  //成员函数
  void init(int n);//n为列数
  void remove(int c); 
  void restore(int c);
  bool dfs(int d);//d为递归深度
  bool solve();
  void addRow(int r);

  //数独所需函数
  void build();
  void decode(int code,int &a,int &b,int &c);
  inline int encode(int a,int b,int c);
  void output();
  inline int trans(int x,int y);

};
#define FOR(i,A,s) for(int i = A[s]; i != s; i = A[i]) 
void DLX::output() {
  for(int i=0;i<ansd;i++){
      int r,c,v;
      decode(ans[i],r,c,v);
      sudoku[r][c]=v;
  }
  for(int i=0;i<9;i++){
      for(int j=0;j<9;j++){
      printf("%d",sudoku[i][j]+1);
      }
      putchar('\n');
  }
}
void DLX::addRow(int r) {
    int first = sz;
    for(int i = 0; i < vec.size(); i++) {
      int c = vec[i];
    //    cout<<c<<" ";
      L[sz] = sz - 1; R[sz] = sz + 1; D[sz] = c; U[sz] = U[c];
      D[U[c]] = sz; U[c] = sz;
      row[sz] = r; col[sz] = c;
      S[c]++; sz++;
    }
    //    cout<<endl;
    R[sz - 1] = first; L[first] = sz - 1;
}
inline int DLX::encode(int a,int b,int c){
  return 81*a + b*9+c+1;
}
inline int DLX::trans(int x,int y){
  x = x/3;
  y = y/3;
  return x*3+y;
}
void DLX::build() {
  for(int i=0;i<9;i++) {
      for(int j=0;j<9;j++) {
    for(int k=0;k<9;k++){
        if(sudoku[i][j]==-1||sudoku[i][j]==k){
        //cout<<i<<" "<<j<<" "<<k<<endl;
        vec.clear();
        vec.push_back(encode(0,i,j));
        vec.push_back(encode(1,i,k));
        vec.push_back(encode(2,j,k));
        vec.push_back(encode(3,trans(i,j),k));            
        addRow(encode(i,j,k));
        }
    }
      }
  }
  return;
}

void DLX::init(int n) { // n是列数
    this->n = n;

    // 虚拟结点
    for(int i = 0 ; i <= n; i++) {
      U[i] = i; D[i] = i; L[i] = i-1, R[i] = i+1;
    }
    R[n] = 0; L[0] = n;

    sz = n + 1;
    memset(S, 0, sizeof(S));
}
void DLX::remove(int c) {
    L[R[c]] = L[c];
    R[L[c]] = R[c];
    FOR(i,D,c)
      FOR(j,R,i) { U[D[j]] = U[j]; D[U[j]] = D[j]; --S[col[j]]; }
}

void DLX::restore(int c) {
    FOR(i,U,c)
    FOR(j,L,i) { ++S[col[j]]; U[D[j]] = j; D[U[j]] = j; }
    L[R[c]] = c;
    R[L[c]] = c;
}
bool DLX::dfs(int d) {
    if (R[0] == 0) { // 找到解
      ansd = d; // 记录解的长度
      return true;
    }

    // 找S最小的列c
    int c = R[0]; // 第一个未删除的列
    FOR(i,R,0) if(S[i] < S[c]) c = i;

    remove(c); // 删除第c列
    FOR(i,D,c) { // 用结点i所在行覆盖第c列
      ans[d] = row[i];
      FOR(j,R,i) remove(col[j]); // 删除结点i所在行能覆盖的所有其他列
      if(dfs(d+1)) return true;
      FOR(j,L,i) restore(col[j]); // 恢复结点i所在行能覆盖的所有其他列
    }
    restore(c); // 恢复第c列

    return false;
}

void DLX::decode(int code,int &a,int &b,int &c){
  code--;
  c = code%9;code/=9;
  b = code%9;code/=9;
  a = code;
}

bool DLX::solve() {
    if(!dfs(0)) return false;
    return true;
}


void input(){

    for(int i=0;i<9;i++) 
    for(int j=0;j<9;j++)
        scanf("%1d",&sudoku[i][j]),sudoku[i][j]--;
}
DLX dlx;
int main(){
    scanf("%d",&_);
    while(_--) {
    input();
    dlx.init(81*4);
    dlx.build();
    bool ok = dlx.solve();
    if(ok) {
        dlx.output();
    }

    }
}
poj2676

 

转载于:https://www.cnblogs.com/greenty1208/p/9898516.html

weixin_30268921
关注
【算法】Dancing Links (DLX) II
听雨草堂
10-27 2360
1. 应用 在前一篇中，简要地介绍了DLX算法，这篇将主要讲DLX的应用。DLX是用来解决extract cover问题的，有一些问题如果能转化成extract cover问题，也就意味着能用DLX求解。 1.1 数独问题 数独（Sudoku）问题是在一个9 * 9的格子上，分为9个宫。有一些格子是已经填好了的，你的目标是把剩下的每一个格子填上1-9中的某一个数，使得
DLX算法一览
热门推荐
蒟蒻QMQ
11-04 1万+
首先了解DLX是什么？ DLX是一种多元未饱和型指令集结构，DLX 代表中级车、加长轴距版本、内饰改款、尊贵车豪华版车型。—百科百度 不不不，我不讲这些明明就是不懂 DLX是什么，一种解决精准覆盖问题的做法，一般不叫算法，下面讲。 模版题： 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 小Ho最近遇到一个难题，他需要破解一个棋局。 棋局分成了n行，m列，每行有若干个...
DLX算法
dianzhenquan3519的博客
09-05 470
理解DLX算法之前首先了解精确覆盖问题和重复覆盖问题 精确覆盖问题 何为精确覆盖问题 　　在一个全集X中若干子集的集合为S，精确覆盖（Exactcover）是指，S的子集S*，满足X中的每一个元素在S*中恰好出现一次。 定义　 　　满足以下条件的集合为一个精确覆盖：　　　　S*中任意两个集合没有交集，即X中的元素在S*中出现最多一次　　　　S*中集合的全集为X，即X中的元素...
DLX算法合集 I
solotzg
02-22 1226
DLX是一种相当神奇的数据结构，通常用于解决矩阵（多为稀疏矩阵）的 重复|精确 覆盖的问题。不过一般这类问题的难点是抽出转化关系，剩下的几乎就是套模板
链表上的舞者——舞蹈链（DLX算法）
m0_52447591的博客
09-12 4706
在整个求解过程中，指针在数据间跳跃着，就像精巧设计的舞蹈一样，故Donald E.Knuth把它称为Dancing Links（中文译名舞蹈链）。 目录 1.1一类被称为精确覆盖的问题 1.2经典的精确覆盖问题举例——矩阵覆盖 1.2.1问题描述 1.2.2从暴力算法到X算法 第二部分：精确覆盖问题的X算法 2.1X算法分析——矩阵覆盖问题的解决 第三部分：用于X算法的数据结构——双向十字循环链表 3.1主角登场——双向十字循环链表概览 3.2详细分析——双向十字循环链表的操作 ...
ACM算法模板小汇总
羽歌Yo的博客
06-24 2619
一篇想到哪写到哪 · 不太全面的模板大集锦。
基于DLX指令集的5级流水线CPU设计与实现
ww_zidongkong的专栏
02-26 6322
一、渊源... 1 二、基础... 2 1、从系统角度和程序执行角度体会CPU概貌... 2 2、CPU设计的重点：指令集和流水线，指令集就是协议... 3 3、流水线—20世纪最伟大的发明... 10 4、流水线带来的烦恼—相关... 16 5、流水线结构的颠覆：记分牌与tomasulo算法（与设计无关）... 21 三、设计与实现... 26 一、渊源 诞
高级计算机图形学笔记
锅巴
12-19 1277
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-03ryXxuU-1576743462382)(G:%5Cmd_files%5Cphoto_file%5Cimage-20191215144426468.png)] 长安大学-柳有权老师讲授 3D Geometry Representation几何表示 Topological information(拓扑信息) Geom...
"并行多线程DPLL算法: 设计与实现
理论计算机科学电子笔记128（2005）75-90www.elsevier.com/locate/entcs并行多线程可满足性求解器的设计与实现Yulik Feldmana、Nachum Dershowitzb和Ziyad Hannaaa英特尔公司，海法，{yulik.feldman，ziyad.hanna}@ ...
阿里力推双Q：RabbitMQ与RocketMQ，电子版手绘脑图+学习指南+面试，你知道多少？
m0_55849656的博客
06-14 348
阿里力推双Q：RabbitMQ与RocketMQ，电子版手绘脑图+学习指南+面试
sudoku-solver:使用DLX算法的快速数独难题求解器:puzzle_piece:
05-07
数独解算器 使用DLX算法的快速数独难题求解器 演示页面 参考
【算法】Dancing Links (DLX) I
听雨草堂
10-25 4316
1.概述 Dacing Links (DLX) 算法是Donald Knuth [2]提出，用以解决精确覆盖（extract cover）问题。 1.1 精确覆盖问题 所谓精确覆盖，是指两两不相交的子集的集合，这些子集的并集可以得到全集。完整的定义 [1]如下： 在一个全集X中若干子集的集合为S，精确覆盖是指，S的子集S*，满足X中的每一个元素在S*中恰好出现一次。
搜索：DLX算法
weixin_30409849的博客
09-11 142
精确覆盖问题：在一个0-1矩阵中，选定部分行，使得每一列都有且只有一个1。求解一种选法 舞蹈链(Dance Link),也就是一个循环十字链表，可以快速的删掉和恢复某行某列 结合了舞蹈链的搜索就称作DLX算法 这里贴一个用DLX算法解决16×16数独的代码 9×9的直接暴力会更好 1 // LA2659 Sudoku 2 // Rujia Liu 3 #include...
Sudoku (DLX 算法)
非确定有限状态自动机
06-22 798
用DLX来解决16*16 数独问题。#include #include #include #include #include #include #include using namespace std; const int maxn = 2010; const int maxnode = 20010; const int maxr = 5010; struct DLX { int n,s
数独问题——DLX算法
a_forever_dream的博客
07-15 1056
如果还没有看过DLX算法请点这里~ 题目传送门 回想一下精确覆盖问题，它的要求是每一列恰好有一个1，那么我们可以考虑将每一列作为一个限制条件，那么将数独的限制条件套进去即可。 考虑数独的限制条件： 每一个空只能填一个数（这不是废话吗。。） 每一行中不能出现重复的数字，而且只能填1~9 每一列中不能出现重复的数字，而且只能填1~9 每一个宫中不能出现重复的数字，而且只能填1~9 这样看好像不是很...
DLX算法解数独游戏 Java版
魔神翼
07-11 2924
使用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);          
Sudoku DLX算法求解
anningzte的专栏
08-20 3177
<br />---------------------------------------- .h<br />#ifndef _DLX_SUDOKU_H_<br />#define _DLX_SUDOKU_H_<br />#include <string><br />using namespace std;<br /><br />#define RR      729             // 81 * 9<br />#define CC      324             // 81 * 4<b
【精确覆盖问题】DLX算法
生息之地
05-12 1101
数独问题最优算法 // 行编号从1开始，列编号为1~n，结点0是表头结点; 结点1~n是各列顶部的虚拟结点 struct DLX { int n, sz; // 列数，结点总数 int S[maxn]; // 各列结点数 int row[maxnode], col[maxnode]; // 各结点行列编号 int L[maxnode], R[maxnode], U[
dancing link X算法（DLX算法）详解
int_Brosea的博客
08-09 1423
我觉得这个博客讲的很不错，就转载过来啦。 理解DLX算法的含义这个很不错，但是拿来做算法竞赛题，我还是觉得kuangbin大佬的板子（静态链表）比较好用。 转载自：https://philoscience.iteye.com/blog/1537004 Exact-Cover问题： 问题描述：给定一个0/1矩阵（一般是稀疏矩阵），选出一些行，使得由这些行构成的新矩阵中每一列有且仅有一个1。换个说法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值