初学DLX

前言

\(DLX\)，全称\(Dancing\ Links\ X\)，即舞蹈链算法。

这是一个十分高效且实用的算法，它主要用于求出精确覆盖问题的一组解。（貌似重复覆盖问题也可以，但我不会\(2333\)）

前置基础：十字链表

\(DLX\)这个算法，建立于十字链表的基础之上。

十字链表，就相当于对于一个链表中的节点，我们要维护它上、下、左、右四个方向的相邻节点。

似乎挺好理解的？

而它的作用，就在于可以很好地维护一个矩阵行列的删除，是\(DLX\)这个算法的基础。

什么是精确覆盖问题？

给你一个集合，以及它的若干子集，先要你选择其中一部分子集，使得集合中的每个元素出现且恰好出现一次。

这就是精确覆盖问题。

\(DLX\)的大致思想

我们以每个子集作为矩阵中的行，以每个元素作为矩阵中的列。如果子集中含有某个元素，就将对应行、列上的元素变为\(1\)，否则为\(0\)。

例如集合为\(\{1,2,3,4,5,6,7,8\}\)，子集为\(\{1,2,3,5,7\},\{1,3,4,8\},\{2,6\},\{4,6,8\},\{5,7\}\)，就可以建出这样一个矩阵：

	\(1\)	\(2\)	\(3\)	\(4\)	\(5\)	\(6\)	\(7\)	\(8\)
\(1\)	\(1\)	\(1\)	\(1\)	\(0\)	\(1\)	\(0\)	\(1\)	\(0\)
\(2\)	\(1\)	\(0\)	\(1\)	\(1\)	\(0\)	\(0\)	\(0\)	\(1\)
\(3\)	\(0\)	\(1\)	\(0\)	\(0\)	\(0\)	\(1\)	\(0\)	\(0\)
\(4\)	\(0\)	\(0\)	\(0\)	\(1\)	\(0\)	\(1\)	\(0\)	\(1\)
\(5\)	\(0\)	\(0\)	\(0\)	\(0\)	\(1\)	\(0\)	\(1\)	\(0\)

然后我们要考虑，每一列只能被选择一次，因此，就能得到\(DLX\)的核心思想：

选择了某一行，就需要删掉所有这一行为\(1\)的列，以及这些列上为\(1\)的行。

以上面的表格为例，假设我们删去了第一行，则需要删除\(1,2,3,5,7\)这\(5\)列，而\(1,2,3,5\)这\(4\)行在这\(5\)列上有\(1\)，因此要删去这\(4\)行。

所以最后剩下的表格是这样的：

	\(4\)	\(6\)	\(8\)
\(4\)	\(1\)	\(1\)	\(1\)

可以发现，在我们删完第\(4\)行后，整个矩阵就为空了，因此，\(1,4\)是一组合法解。

而如果删完所有行后依然存在某些列没被删，就说明这种选择方式不合法。

具体实现：初始化

一开始，我们要先按照元素总数建好每一列，每个点用一个十字链表存储，上下都指向自己，左右指向相邻节点。（特殊地，最左端指向最右端，最右端指向最左端）

这一过程代码如下：

struct node//十字链表上的一个节点
{
int x,y,u,d,l,r;//坐标(x,y)，剩余四个变量分别存储上、下、左、右的相邻节点
I node(CI X=0,CI Y=0,CI U=0,CI D=0,CI L=0,CI R=0):x(X),y(Y),u(U),d(D),l(L),r(R){}//构造函数
}O[N*N+5];
I void Init(CI x)//初始化有x个元素
{
RI i;for(tot=x,i=0;i<=x;++i) O[i]=node(0,i,i,i,i-1,i+1);//对于0~x列，每个元素上下指向自己，左右指向相邻节点
O[O[0].l=x].r=0,memset(lnk,-1,sizeof(lnk));//最左端指向最右端，最右端指向最左端，并初始化lnk为-1
}

具体实现：插入元素

接下来，我们需要把矩阵中为\(1\)的元素一个个插入矩阵。

考虑插入要做些什么。

首先，我们要更新这一列的\(Size\)值加\(1\)（用于搜索剪枝，不然会跑的很慢）。

然后我们为其新建一个节点，更新十字链表的信息。

唯一需要注意的是如果这个节点是该行的第一个节点，则需要将其作为行头节点。

这一过程代码如下：

I void Insert(CI x,CI y)//插入节点
{
++sz[y],O[++tot]=node(x,y,y,O[y].d),O[y].d=O[O[y].d].u=tot,//更新Size，建新节点，更新上下信息
if(~lnk[x]) O[tot].l=lnk[x],O[tot].r=O[lnk[x]].r,O[lnk[x]].r=O[O[lnk[x]].r].l=tot;//如果已有行头节点，更新左右节点
else lnk[x]=O[tot].l=O[tot].r=tot;//否则将其作为行头节点
}

具体实现：删除与还原

由前面我们知道，\(DLX\)的核心思想在于删除行列与还原。

考虑删除一列（还原类似），我们需要删除这一列上值为\(1\)的所有行，因此我们会先枚举列上的每一个元素，然后枚举当前元素所在行的每一元素，将其删去。

代码如下：

I void Delete(CI x)//删除
{
O[O[O[x].l].r=O[x].r].l=O[x].l;//从列中删除
for(RI i=O[x].d;i^x;i=O[i].d) for(RI j=O[i].r;j^i;j=O[j].r)//枚举列中元素和该元素所在的行
O[O[O[j].u].d=O[j].d].u=O[j].u,--sz[O[j].y];//删除
}
I void Regain(CI x)//还原
{
for(RI i=O[x].d;i^x;i=O[i].d) for(RI j=O[i].r;j^i;j=O[j].r)//枚举列中元素和该元素所在的行
O[O[j].u].d=O[O[j].d].u=j,++sz[O[j].y];//还原
O[O[x].l].r=O[O[x].r].l=x;//还原到列中
}

具体实现：\(Dance\)搜索

以上这些其实都只是辅助，真正核心的其实是\(Dance\)这个函数。

首先，我们要判断当前是否已为空矩阵，如果是，则说明已经找到一组合法解，输出即可。

否则，我们找到元素个数最少，即\(Size\)最小的一列，来进行操作（这应该是搜索一个常用剪枝吧）。

操作的过程就是枚举删除这一列的哪一行来删去，记得搜完一行要还原。