浅谈舞蹈链(DLX)

已于 2022-02-14 11:50:03 修改
阅读量1.0k 收藏 11
点赞数 2
分类专栏： OI 文章标签： 算法 数据结构
于 2021-08-09 01:58:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50332374/article/details/119526352
版权

前言

舞蹈链的名字真好玩…

文章目录

一、舞蹈链概述

舞蹈链 (Dancing links)，也叫 DLX ，是由 Donald Knuth 提出的数据结构，目的是快速实现他提出的X算法。X算法是一种递归算法，时间复杂度不确定，深度优先，通过回溯寻找精确覆盖问题所有可能的解

（以上摘自维基百科）

舞蹈链的主要思想来源于双向链表

我们设 l [ x ] l[x] l[x] 表示元素 x x x 的左指针， r [ x ] r[x] r[x] 表示元素 x x x 的右指针

显然，如果想要删除元素 x x x ，我们可以做以下操作

r[l[x]]=r[x]; // x左侧的元素的右指针指向x右侧的元素
l[r[x]]=l[x]; // x右侧的元素的左指针指向x左侧的元素

那恢复元素 x x x 呢？ 我们可以发现删除 x x x 的时候， x x x 的左右指针并没有改变，即 l [ x ] l[x] l[x] 和 r [ x ] r[x] r[x] 并没有改变，于是我们可以做以下操作

r[l[x]]=x; // x左侧的元素的右指针重新指向x
l[r[x]]=x; // x右侧的元素的左指针重新指向x

这样如果 x x x 左右两侧没有改变，我们就可以恢复 x x x 所在的位置

那么精确覆盖问题又是什么呢？

给定矩阵，要求选出一个由若干行组成的集合，使得每一列上都有且仅有一个 1 1 1

( 0 0 1 0 1 1 0 1 0 0 1 0 0 1 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 1 ) \begin{pmatrix}0&0&1&0&1&1&0 \\ 1&0&0&1&0&0&1 \\ 0&1&1&0&0&1&0 \\ 1&0&0&1&0&0&0 \\ 0&1&0&0&0&0&1 \\ 0&0&0&1&1&0&1\end{pmatrix} ⎝⎜⎜⎜⎜⎜⎜⎛​010100​001010​101000​010101​100001​101000​010011​⎠⎟⎟⎟⎟⎟⎟⎞​

例如该矩阵选出的行为 1 , 4 , 5 1,4,5 1,4,5 行

我们来模拟一下朴素X算法求解的过程

以下过程用红色表示选择了这一行，绿色表示存在冲突的元素，灰色表示删除的行

1.选择第一行

( 0 0 1 0 1 1 0 1 0 0 1 0 0 1 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 1 ) \begin{pmatrix}\color{red}0&\color{red}0&\color{red}1&\color{red}0&\color{red}1&\color{red}1&\color{red}0 \\ 1&0&0&1&0&0&1 \\ 0&1&1&0&0&1&0 \\ 1&0&0&1&0&0&0 \\ 0&1&0&0&0&0&1 \\ 0&0&0&1&1&0&1\end{pmatrix} ⎝⎜⎜⎜⎜⎜⎜⎛​010100​001010​101000​010101​100001​101000​010011​⎠⎟⎟⎟⎟⎟⎟⎞​

2.标记所有和第一行冲突的元素

( 0 0 1 0 1 1 0 1 0 0 1 0 0 1 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 1 ) \begin{pmatrix}\color{red}0&\color{red}0&\color{red}1&\color{red}0&\color{red}1&\color{red}1&\color{red}0 \\ 1&0&0&1&0&0&1 \\ 0&1&\color{green}1&0&0&\color{green}1&0 \\ 1&0&0&1&0&0&0 \\ 0&1&0&0&0&0&1 \\ 0&0&0&1&\color{green}1&0&1\end{pmatrix} ⎝⎜⎜⎜⎜⎜⎜⎛​010100​001010​101000​010101​100001​101000​010011​⎠⎟⎟⎟⎟⎟⎟⎞​

3.删除存在冲突的行

( 0 0 1 0 1 1 0 1 0 0 1 0 0 1 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 1 ) \begin{pmatrix}\color{red}0&\color{red}0&\color{red}1&\color{red}0&\color{red}1&\color{red}1&\color{red}0 \\ 1&0&0&1&0&0&1 \\ \color{grey}0&\color{grey}1&\color{grey}1&\color{grey}0&\color{grey}0&\color{grey}1&\color{grey}0 \\ 1&0&0&1&0&0&0 \\ 0&1&0&0&0&0&1 \\ \color{grey}0&\color{grey}0&\color{grey}0&\color{grey}1&\color{grey}1&\color{grey}0&\color{grey}1\end{pmatrix} ⎝⎜⎜⎜⎜⎜⎜⎛​010100​001010​101000​010101​100001​101000​010011​⎠⎟⎟⎟⎟⎟⎟⎞​

4.接着选择第二行

( 0 0 1 0 1 1 0 1 0 0 1 0 0 1 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 1 ) \begin{pmatrix}\color{red}0&\color{red}0&\color{red}1&\color{red}0&\color{red}1&\color{red}1&\color{red}0 \\ \color{red}1&\color{red}0&\color{red}0&\color{red}1&\color{red}0&\color{red}0&\color{red}1 \\ \color{grey}0&\color{grey}1&\color{grey}1&\color{grey}0&\color{grey}0&\color{grey}1&\color{grey}0 \\ 1&0&0&1&0&0&0 \\ 0&1&0&0&0&0&1 \\ \color{grey}0&\color{grey}0&\color{grey}0&\color{grey}1&\color{grey}1&\color{grey}0&\color{grey}1\end{pmatrix} ⎝⎜⎜⎜⎜⎜⎜⎛​010100​001010​101000​010101​100001​101000​010011​⎠⎟⎟⎟⎟⎟⎟⎞​

5.标记与第二行冲突的元素

( 0 0 1 0 1 1 0 1 0 0 1 0 0 1 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 1 ) \begin{pmatrix}\color{red}0&\color{red}0&\color{red}1&\color{red}0&\color{red}1&\color{red}1&\color{red}0 \\ \color{red}1&\color{red}0&\color{red}0&\color{red}1&\color{red}0&\color{red}0&\color{red}1 \\ \color{grey}0&\color{grey}1&\color{grey}1&\color{grey}0&\color{grey}0&\color{grey}1&\color{grey}0 \\ \color{green}1&0&0&\color{green}1&0&0&0 \\ 0&1&0&0&0&0&\color{green}1 \\ \color{grey}0&\color{grey}0&\color{grey}0&\color{grey}1&\color{grey}1&\color{grey}0&\color{grey}1\end{pmatrix} ⎝⎜⎜⎜⎜⎜⎜⎛​010100​001010​101000​010101​100001​101000​010011​⎠⎟⎟⎟⎟⎟⎟⎞​

6.删除存在冲突的行

( 0 0 1 0 1 1 0 1 0 0 1 0 0 1 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 1 ) \begin{pmatrix}\color{red}0&\color{red}0&\color{red}1&\color{red}0&\color{red}1&\color{red}1&\color{red}0 \\ \color{red}1&\color{red}0&\color{red}0&\color{red}1&\color{red}0&\color{red}0&\color{red}1 \\ \color{grey}0&\color{grey}1&\color{grey}1&\color{grey}0&\color{grey}0&\color{grey}1&\color{grey}0 \\ \color{grey}1&\color{grey}0&\color{grey}0&\color{grey}1&\color{grey}0&\color{grey}0&\color{grey}0 \\ \color{grey}0&\color{grey}1&\color{grey}0&\color{grey}0&\color{grey}0&\color{grey}0&\color{grey}1 \\ \color{grey}0&\color{grey}0&\color{grey}0&\color{grey}1&\color{grey}1&\color{grey}0&\color{grey}1\end{pmatrix} ⎝⎜⎜⎜⎜⎜⎜⎛​010100​001010​101000​010101​100001​101000​010011​⎠⎟⎟⎟⎟⎟⎟⎞​

7.发现没有可以选择的行了，而已选的不满足要求，回溯，选择第四行

( 0 0 1 0 1 1 0 1 0 0 1 0 0 1 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 1 ) \begin{pmatrix}\color{red}0&\color{red}0&\color{red}1&\color{red}0&\color{red}1&\color{red}1&\color{red}0 \\ 1&0&0&1&0&0&1 \\ \color{grey}0&\color{grey}1&\color{grey}1&\color{grey}0&\color{grey}0&\color{grey}1&\color{grey}0 \\ \color{red}1&\color{red}0&\color{red}0&\color{red}1&\color{red}0&\color{red}0&\color{red}0 \\ 0&1&0&0&0&0&1 \\ \color{grey}0&\color{grey}0&\color{grey}0&\color{grey}1&\color{grey}1&\color{grey}0&\color{grey}1\end{pmatrix} ⎝⎜⎜⎜⎜⎜⎜⎛​010100​001010​101000​010101​100001​101000​010011​⎠⎟⎟⎟⎟⎟⎟⎞​
8.接下来的同理，不断执行，直到找到答案

我们会发现， X X X 算法花了大量的时间在找 1 1 1 ，而且删改很不方便

为了解决这个问题，舞蹈链就产生了

模板题 → \to → P4929 【模板】舞蹈链（DLX）

（注：为了方便讲述，以下引用这篇博客中的图片（感谢图片的作者！））

舞蹈链的结构即交叉十字循环双向链，本文中以数组形式实现链表

int n,m; // 行、列数
int u[MAXN],d[MAXN],l[MAXN],r[MAXN],h[MAXN]; 
// 每个结点的上下左右指针；每一行的头指针

int row[MAXN],col[MAXN],s[MAXN],ansk[MAXN],pos; 
// 每个结点原先所在的行、列；每一列的结点个数；ansk记录搜索信息；结点总数

如下图所示
在这里插入图片描述
别急！我们一步一步来实现这个复杂的数据结构

首先初始化上方的列头结点

我们可以称列头结点为限制，行头结点为决策 （注：这个做题的时候有用）

void init()
{
	for(R int i=0; i<=m; i++)
	{
		l[i]=i-1;
		r[i]=i+1;
		u[i]=d[i]=i; 
	}
	l[0]=m;r[m]=0; //循环链表
	memset(h,-1,sizeof(h)); //每一行的头结点都为空
	memset(s,0,sizeof(s)); //每一列的结点数都为0
	pos=m+1; //已经搭建好了m个列头结点，下一个加入的结点从m+1开始编号
}

接下来，我们来把插入结点的功能完成（注：这里比较复杂，可以感性理解一下）

void link(R int x,R int y)
{
	s[y]++; //所在的列结点数加1
	row[pos]=x;col[pos]=y; //记录编号为pos的结点（即新加入的结点）的行和列
	u[pos]=y; //pos结点的上指针指向插入的列y
	d[pos]=d[y]; //pos结点的下指针指向插入位置下方的元素
	u[d[y]]=pos; //插入位置下方的元素的上指针指向pos结点
	d[y]=pos; //插入位置上方的下指针指向pos结点
	if(h[x]<0)h[x]=l[pos]=r[pos]=pos;//如果pos结点所在的这一行没有头结点，就自己当
	else //不然就插入头结点一侧 （下面的就不注释了，和上面插入的方法类似）
	{
		l[pos]=l[h[x]];
		r[pos]=h[x];
		r[l[h[x]]]=pos;
		l[h[x]]=pos;
	}
	pos++; //下一个结点不要标错号了
}

现在我们来完成删除和恢复操作（差不多的）

inline void rm(R int y)
{
	l[r[y]]=l[y];r[l[y]]=r[y];//删除y列的结点（这个位置已经填满了）
	for(R int i=d[y]; i!=y; i=d[i])
		for(R int j=r[i]; j!=i; j=r[j])//删除这一行（冲突的行）
		{
			d[u[j]]=d[j];
			u[d[j]]=u[j];
			s[col[j]]--;//别忘了减1
		}
}
inline void rv(R int y)
{
	for(R int i=u[y]; i!=y; i=u[i])
		for(R int j=l[i]; j!=i; j=l[j])//恢复也是一样的
		{
			d[u[j]]=j;
			u[d[j]]=j;
			s[col[j]]++;
		}
	r[l[y]]=y;l[r[y]]=y;
}

然后可以开始跳舞了
主体部分，就是深度优先搜索

bool dance(R int dep)
{
	if(!r[0])//所有的列头结点都被选了，说明成功了
	{
		for(R int i=0; i<dep; i++)
			printf("%lld%c",ansk[i]," \n"[i==dep-1]);
		return 1;
	}
	R int y=r[0];
	for(R int i=r[0]; i; i=r[i])
		if(s[i]<s[y])y=i;//这里是一个剪枝，每次选择结点最少的列能在一定情况下提高性能
	rm(y);//删掉这一列
	for(R int i=d[y]; i!=y; i=d[i])//每次选择这列中的一行
	{
		ansk[dep]=row[i];
		for(R int j=r[i]; j!=i; j=r[j])rm(col[j]);//删掉这一行中所有结点（这一行冲突）
		if(dance(dep+1))return 1;//成功就返回
		for(R int j=l[i]; j!=i; j=l[j])rv(col[j]);//恢复
	}
	rv(y);
	return 0;
}

如果您不太理解的话，可以看看下面的动图（注：其实和之前模拟的有些相似）

算法执行过程 （注：图片是这篇博客的）

在这里插入图片描述

最终的答案即下图 （选择 1 , 4 , 5 1,4,5 1,4,5 ）
在这里插入图片描述
最后贴上完整代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define R register
#define MAXN 250505
template<typename T>inline void read(R T &k)
{
	R char ch=getchar(); R T x=0,f=1;
	while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(isdigit(ch)){x=(x<<3)+(x<<1)+(ch^48);ch=getchar();}
	k=x*f;
}
int n,m;
int u[MAXN],d[MAXN],l[MAXN],r[MAXN],h[MAXN];
int row[MAXN],col[MAXN],s[MAXN],ansk[MAXN],pos;
void init()
{
	for(R int i=0; i<=m; i++)
	{
		l[i]=i-1;
		r[i]=i+1;
		u[i]=d[i]=i;
	}l[0]=m;r[m]=0;
	memset(h,-1,sizeof(h));
	memset(s,0,sizeof(s));
	pos=m+1;
}
void link(R int x,R int y)
{
	s[y]++;
	row[pos]=x;col[pos]=y;
	u[pos]=y;
	d[pos]=d[y];
	u[d[y]]=pos;
	d[y]=pos;
	if(h[x]<0)h[x]=l[pos]=r[pos]=pos;
	else
	{
		l[pos]=l[h[x]];
		r[pos]=h[x];
		r[l[h[x]]]=pos;
		l[h[x]]=pos;
	}
	pos++;
}
inline void rm(R int y)
{
	l[r[y]]=l[y];r[l[y]]=r[y];
	for(R int i=d[y]; i!=y; i=d[i])
		for(R int j=r[i]; j!=i; j=r[j])
		{
			d[u[j]]=d[j];
			u[d[j]]=u[j];
			s[col[j]]--;
		}
}
inline void rv(R int y)
{
	for(R int i=u[y]; i!=y; i=u[i])
		for(R int j=l[i]; j!=i; j=l[j])
		{
			d[u[j]]=j;
			u[d[j]]=j;
			s[col[j]]++;
		}
	r[l[y]]=y;l[r[y]]=y;
}
bool dance(R int dep)
{
	if(!r[0])
	{
		for(R int i=0; i<dep; i++)
			printf("%lld%c",ansk[i]," \n"[i==dep-1]);
		return 1;
	}
	R int y=r[0];
	for(R int i=r[0]; i; i=r[i])
		if(s[i]<s[y])y=i;
	rm(y);
	for(R int i=d[y]; i!=y; i=d[i])
	{
		ansk[dep]=row[i];
		for(R int j=r[i]; j!=i; j=r[j])rm(col[j]);
		if(dance(dep+1))return 1;
		for(R int j=l[i]; j!=i; j=l[j])rv(col[j]);
	}
	rv(y);
	return 0;
}
signed main()
{
	read(n);read(m);
	init();
	for(R int i=1; i<=n; i++)
		for(R int j=1,t; j<=m; j++)
		{
			read(t);
			if(t)link(i,j);
		}
	if(!dance(0))puts("No Solution!");
	return 0;
}

二、舞蹈链例题

如果您看到这里，还是很明白的话，那么我们来讲个例题

题目链接：SP13980 SUDOGOB - Sudoku goblin

题意：给定一个 9 × 9 9 \times 9 9×9 的数独，输出可填的方案数，多组数据

选择这个例题当然不是让你写暴搜的

首先考虑决策

每个格子上填数字，至多有 9 × 9 × 9 = 729 9\times 9\times 9 = 729 9×9×9=729 种决策

再考虑限制

  1. 每个点只能填一个数
  2. 每行一个数只能填一次
  3. 每列一个数只能填一次
  4. 每个九宫格一个数只能填一次

限制数为 9 × 9 × 4 = 324 9\times 9 \times 4 = 324 9×9×4=324

对于精准覆盖问题，我们本质上是在选择若干决策，使其恰好满足所有限制条件

因此这题可以用 DLX 求解

那么 MAXN只要开到 729*324 就行了（注：不过开大点保险）

这题唯一的细节是插入结点的行、列，还是很简单的题目

代码如下

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define R register
#define MAXN (729*324+6666)
int Q;
bool suc;
int a[25][25];
int ans[25][25],Ans;
int h[MAXN],l[MAXN],r[MAXN],u[MAXN],d[MAXN];
int row[MAXN],col[MAXN],pos,s[MAXN],ansk[MAXN];
template<typename T>inline void read(R T &k)
{
	R char ch=getchar();R T x=0,f=1;
	while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(isdigit(ch)){x=(x<<3)+(x<<1)+(ch^48);ch=getchar();}
	k=x*f;
}
inline void init()
{
	int m=324;Ans=0;suc=0;
	for(R int i=0; i<=m; i++)
	{
		l[i]=i-1;r[i]=i+1;
		u[i]=d[i]=i;
	}
	l[0]=m;r[m]=0;
	memset(s,0,sizeof(s));
	memset(h,-1,sizeof(h));
	pos=m+1;
}
inline void link(R int x,R int y)
{
	s[y]++;
	row[pos]=x;col[pos]=y;
	u[pos]=y;
	d[pos]=d[y];
	u[d[y]]=pos;
	d[y]=pos;
	if(h[x]<0)h[x]=l[pos]=r[pos]=pos;
	else
	{
		l[pos]=l[h[x]];
		r[pos]=h[x];
		r[l[h[x]]]=pos;
		l[h[x]]=pos;
	}
	++pos;
}
inline void rm(R int y)
{
	r[l[y]]=r[y];l[r[y]]=l[y];
	for(R int i=d[y]; i!=y; i=d[i])
		for(R int j=r[i]; j!=i; j=r[j])
		{
			u[d[j]]=u[j];
			d[u[j]]=d[j];
			s[col[j]]--;
		}
}
inline void rv(R int y)
{
	for(R int i=u[y]; i!=y; i=u[i])
		for(R int j=l[i]; j!=i; j=l[j])
		{
			u[d[j]]=j;
			d[u[j]]=j;
			s[col[j]]++;
		}
	l[r[y]]=y;r[l[y]]=y;
}
void dance(R int dep)
{
	if(!r[0])
	{
		Ans++;
		if(Ans>1)suc=1;
		for(R int i=0; i<dep&&!suc; i++)
		{
			R int x=(ansk[i]-1)/9/9+1;
			R int y=(ansk[i]-1)/9%9+1;
			R int z=(ansk[i]-1)%9+1;
			ans[x][y]=z;
		}
		return;
	}
	R int y=r[0];
	for(R int i=r[0]; i!=0; i=r[i])
		if(s[i]<s[y])y=i;
	rm(y);
	for(R int i=d[y]; i!=y; i=d[i])
	{
		ansk[dep]=row[i];
		for(R int j=r[i]; j!=i; j=r[j])rm(col[j]);
		dance(dep+1);
		for(R int j=l[i]; j!=i; j=l[j])rv(col[j]);
	}
	rv(y);
}
signed main()
{
	read(Q);
	while(Q--)
	{
		init();
		for(R int i=1; i<=9; i++)
			for(R int j=1; j<=9; j++)
			{
				read(a[i][j]);
				R int &t=a[i][j];
				for(R int k=1; k<=9; k++)
				{
					if(t!=k&&t!=0)continue;
					R int o=(i-1)*9*9+(j-1)*9+k;
					R int c1=81*0 + (i-1)*9+(j-1)+1;
					R int c2=81*1 + (i-1)*9+k;
					R int c3=81*2 + (j-1)*9+k;
					R int c4=81*3 + ((i-1)/3*3+(j-1)/3)*9+k;
					link(o,c1);link(o,c2);link(o,c3);link(o,c4);
				}
			}
		dance(0);
		if(!Ans){puts("0");continue;}
		printf("%lld\n",Ans);
		for(R int i=1; i<=9&&!suc; i++)
			for(R int j=1; j<=9; j++)
				printf("%lld%c",ans[i][j]," \n"[j==9]);
	}
	return 0;
}

当然，如果您有兴趣的话，可以去做下这道题

题目链接：SP1110 SUDOKU - Sudoku

这道题就是上一题的加强版，其实没什么区别，如果您理解了例题的话，这题就很简单了

总结

本文介绍了舞蹈链

转载请说明出处

q779
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java舞蹈链算法_DancingLink 舞蹈链
weixin_27785375的博客
02-26 456
# Dancing Link - 舞蹈链--------#### 问题集合$$ s = [x_{1}, x_{2}, \dots , x_{m}] $$拥有$$ m $$个成员，有$$ n $$个子集$$ t = [ s_{1},s_{2}, \dots ,s_{n} ] $$，其中子集$$ s_{i} $$拥有成员的数量为$$ n_{i} $$($$ 1 \le i \le n, 0 \le n...
舞蹈链，DLX算法详解，OJ精讲，详细代码
最新发布
EQUINOX1的博客
01-11 1195
如何将实际问题抽象为精确覆盖问题？
初次学习舞蹈链Dancing Links
qq_36386435的博客
10-01 654
介绍几个讲的比较好的博客： 这篇博客容易理解，可以先看： http://www.cnblogs.com/grenet/p/3145800.html 这篇博客阐述的也好，而且有实例分析（也是转载自此文）： https://blog.csdn.net/WhereIsHeroFrom/article/details/79220897?utm_source=copy Dancing Links正是十字交叉...
舞蹈链（DLX）
weixin_30347335的博客
07-07 139
舞蹈链（DLX） Tags：搜索 作业部落 评论地址 一、概述 特别特别感谢这位童鞋His blog 舞蹈链是一种优美的搜索，就像下面这样跳舞～ 舞蹈链用于解决精确覆盖或者重复覆盖的问题 你可以想象成贪吃蛇的一个上下左右联通的地图 \(Dancing Links\)就是通过链表这样实现的 网上有图的博客 二、实现 更详细的讲解在课件中 精确覆盖 精确覆盖大概指的就是数独和八皇后那样的问题 矩阵...
舞蹈链（Dancing Links）求解数独
。
03-24 330
讲解（写的太好了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
dlx指令 DLX Instruction Set Architecture
04-09
DLX Instruction Set Architecture
DLX.zip_DLX
09-22
DLX用于高效率搜索，是一种覆盖问题模型的算法。DLX利用了双向链表，体现了数据结构的美。
DLX_Links_DLX_
09-28
dancing links X算法python实现demo程序
DLX.zip_DLX_dlx算法
09-20
DLX算法，是由Knuth提出的一种在图论中图遍历的一种高效算法。
DLX.rar_DLX_dlx文件
09-21
DLX指令集实现程序，将汇编代码转换成二进制代码写入文件中。
舞蹈链数独求解算法
04-10
舞蹈链算法求解数独
Dancing Links---- E - Sudoku
qq_36386435的博客
10-02 251
A Sudoku grid is a 16x16 grid of cells grouped in sixteen 4x4 squares, where some cells are filled with letters from A to P (the first 16 capital letters of the English alphabet), as shown in figure 1...
ACM：搜索算法专题(4)——跳舞链
<code> I am a coder </code>
06-28 778
题目来源：          HihoCoder1317   题目描述：     在N行 M列的棋盘中放置一定数目的棋子，要求从其中选出若干行，使得每一列中恰好有一枚棋子。     例如，对于下面的棋局，选择1、3、4行，则符合要求：           解答： ·精确覆盖问题：     以上问题可以总结为“精确覆盖问题”。具体定义如下：         给定一
跳舞链 nyist511 小球移动
nNbS
03-28 221
题目传送门：http://acm.nyist.net/JudgeOnline/problem.php?pid=511跳舞链是带哨兵节点的双向循环链表，更加优美的形式是将该链表用静态链表的形式实现，使得查找，删除和恢复操作的时间复杂度均为O（1）#include <cstring> #include <cstdio> using namespace std; const int MAX = 10010
dancing links - 舞蹈的链表
古朴匠心
04-26 2147
    看了Donald E. Knuth关于dancing links的原文后，不得不说文章中处处透漏着艺术气息，Knuth不亏是一代大师。  本文不能算是深入的总结，或者说连翻译也算不上，权当是学习dancing links的笔记。  首先解释一下什么是dancing links  对于双向链表，假设x是双向链表的一个元素，L(X)指向x元素的前一个元素，R(X)指
用位操作实现跳舞链
aaron_1996的专栏
06-10 1107
跳舞链跳舞链是著名的计算机科学家高德纳提出的一种使用深度优先搜索来解决精度覆盖问题的算法。其问题的提出是在一个棋盘上，是否可以挑出一些长边，使得每一个宽边上有且仅有一枚棋子。 高德纳认为，这个问题里面宽度和长度是两个相互制约的因素。首先，如果我们选到了一个长边，那么相对应的宽边都得到了覆盖。而与此同时，如果其他长边上的同一位置也存在棋子，那么由于精确性的条件，这些边都不能够再选择了。在搜索的过程中
舞蹈链算法（DLX 算法）略解
破壁人五号的博客
03-15 2100
DLX 是用来解决精确覆盖问题的算法，算是 X 算法的优化。 时间复杂度 $O(玄学)$（最坏是指数级，绝大多数情况跑得很快）。 最经典的应用为求解数独。
舞蹈链java实现_舞蹈链（DLX） - osc_kpp7htz3的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_34501965的博客
02-28 173
#舞蹈链(DLX) Tags：搜索 ##作业部落 ##评论地址##一、概述 特别特别感谢这位童鞋His blog 舞蹈链是一种优美的搜索，就像下面这样跳舞～ 舞蹈链用于解决精确覆盖或者重复覆盖的问题 你可以想象成贪吃蛇的一个上下左右联通的地图 $Dancing Links$就是通过链表这样实现的 网上有图的博客 ##二、实现 ####更详细的讲解在课件中 ###精确覆盖 精确覆盖大概指的就是数独和...
舞蹈链DLX算法
Freopen的博客
06-10 1511
常数与希望编织的一缕奇迹 模板 DLX算法全称：Dancing Line X算法。 X算法的意思就是不知道是哪种搜索算法， 而Dancing Line的意思就是用Dancing Line优化X算法。 Dancing Line是使用在类二维矩阵中的双向循环链表群。 上面的话可以意会 Dancing Line 其实就是对于每个元素，和它左边的第一个，右边的第一个，上边的，下边的，都连上双向指针。 ...
rabbitmq DLX
08-28
RabbitMQ中的DLX（Dead Letter Exchange）是一个重要的概念，它允许将无法被消费者处理的消息路由到另一个交换机上，而不是直接丢弃它们。DLX可以用来处理一些特殊情况，例如消息无法被消费、消息超时或者达到最大重...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值