什么是DLX？
让我们看看百度百科上的解释：在 计算机科学 中, Dancing Links ,舞蹈链, 也叫 DLX, 是由 Donald Knuth 提出的数据结构，目的是快速实现他的 X算法.X算法是一种递归算法，时间复杂度不确定, 深度优先, 通过回溯寻找精确覆盖问题所有可能的解。有一些著名的精确覆盖问题，包括铺砖块，八皇后问题，数独问题。X算法
概念
X算法用由0和1组成的矩阵A来表示精确覆盖问题，目标是选出矩阵的若干行，使得其中的1在所有列中出现且仅出现一次。（出自度娘）实现步骤
1.如果矩阵A为空（没有任何列），则当前局部解即为问题的一个解，返回成功；否则继续。 2.根据一定方法选择第c列。如果某一列中没有1，则返回失败，并去除当前局部解中最新加入的行。 3.选择第r行，使得A[r,c]=1（该步是不确定的）。 4.将第r行加入当前局部解中。 5.对于满足A[r,j]=1的每一列j，从矩阵A中删除所有满足A[i,j]=1的行，最后再删除第j列。 6.对所得比A小的新矩阵递归地执行此算法。图解
>例如有一个这样的矩阵A： $$ mathbf{A} = left( egin{array}{ccc} {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{array} ight) $$ ps:例子引用自[grenet奆佬](http://www.cnblogs.com/grenet/p/3145800.html) 这个例子就包含了一个（1,4,5）的精确覆盖解。1.然后让我们人工模拟一遍X算法，好好体会体会：
最开始首先假定选择第一列：
[left( egin{array}{ccc}
{0} & {0} & {1} & {0} & {1} & {1} & {0} \
{ } & { } & { } & { } & { } & { } & { } \
{ } & { } & { } & { } & { } & { } & { } \
{ } & { } & { } & { } & { } & { } & { } \
{ } & { } & { } & { } & { } & { } & { } \
{ } & { } & { } & { } & { } & { } & { } \
end{array}
ight)
]
那么对于第一行有1的列，即（3,5,6），可向下不断延伸，遇到有1的位置，就把该行标记：
[mathbf{B} =
left( egin{array}{ccc}
{0} & {0} & {1} & {0} & {1} & {1} & {0} \
{ } & { } & {0} & { } & {0} & {0} & { } \
{0} & {1} & {1} & {0} & {0} & {1} & {0} \
{ } & { } & {0} & { } & {0} & {0} & { } \
{ } & { } & {0} & { } & {0} & {0} & { } \
{0} & {0} & {0} & {1} & {1} & {0} & {1} \
end{array}
ight)
]
2.这样就可以用A矩阵-B矩阵（即删除所标记的行和列），得到一个新的、小一点的矩阵A（即得到一个规模较小的精确覆盖问题）:
[mathbf{A} =
left( egin{array}{ccc}
{1} & {0} & {1} & {1} \
{1} & {0} & {1} & {0} \
{0} & {1} & {0} & {1} \
end{array}
ight)
]
3.那么根据1，又可进行一下操作：
先选第一列：
[mathbf{A} =
left( egin{array}{ccc}
{1} & {0} & {1} & {1} \
{ } & { } & { } & { } \
{ } & { } & { } & { } \
end{array}
ight)
]
那么对于第一行有1的列，即（1,3,4），可向下不断延伸，遇到有1的位置，就把该行标记：
[mathbf{B} =
left( egin{array}{ccc}
{1} & {0} & {1} & {1} \
{1} & { } & {1} & {0} \
{0} & {1} & {0} & {1} \
end{array}
ight)
]
4.这样就可以用A矩阵-B矩阵（即删除所标记的行和列），又得到一个新的、小一点的矩阵A（即又得到一个规模较小的精确覆盖问题）:
[mathbf{A} =
left( egin{array}{ccc}
{0}\
end{array}
ight)
]
这个时候我们发现当前A矩阵不为空，也没有一列有1（既无法继续操作）
则这个时候说明之前走出了错误的一步，就需要我们回溯——
5.那么根据步骤就回溯到3：
[mathbf{A} =
left( egin{array}{ccc}
{1} & {0} & {1} & {1} \
{1} & {0} & {1} & {0} \
{0} & {1} & {0} & {1} \
end{array}
ight)
]
这个时候就不能尝试第一行，那我们就标记第二行，并按照之前的方法扩展：
[mathbf{B} =
left( egin{array}{ccc}
{1} & {0} & {1} & {1} \
{1} & {0} & {1} & {0} \
{0} & { } & {0} & { } \
end{array}
ight)
]
6.那么由4，同理我们可得：
[mathbf{A} =
left( egin{array}{ccc}
{1} & {1} \
end{array}
ight)
]
那么继续上面的步骤，显然整个矩阵最后就可以被缩减完。
7.由此，我们就得到了那组解（1,4,5）
DLX算法
那为什么还要用DLX算法呢？直接用X算法不好吗？
根据我们刚才的运行过程，如果过程中有大量的回溯和标记过程，那我们如果用数组存储之前的信息，显然是不可能的，~妥妥的MLE没商量
这个时候我们就要隆重请出舞蹈链的X算法（即DLX）
舞蹈链怎样实现
舞蹈链，即为一个双向十字循环链表，**即每个点都与上下左右四个点连有一条双向指针** **（第一排的up指向最后一排，最后一排的down指向第一排；第一列的left指向最后一列，最后一列的right指向第一列）** **重点：因为是链表，所以我们需要一个初始节点来建表** >1.那么最开始初始化的时候，我们将第一行的指针指好： ```cpp template2.对输入矩阵扫描，对于有1的点进行插入操作：
这样我们就只在1与1之间建链，对于X算法中挨个挨个去扩展来找1就要快得多：
template<typename TP>inline void push(TP r,TP c)
{
U[++cnt]=c,D[cnt]=D[c];
U[D[c]]=cnt,D[c]=cnt;
row[cnt]=r,col[cnt]=c;
if(H[r]!=-1)
{
R[cnt]=R[H[r]],L[R[H[r]]]=cnt;
L[cnt]=H[r],R[H[r]]=cnt;
}
else H[r]=L[cnt]=R[cnt]=cnt;
return;
}
3.对于最关键的删除/回溯操作
因为只将有1的点加入链表，所以直接扫就行
值得一提的是，我们在删除的时候（就是从当前所选列扩展的时候），我们只是把"对应列"有1的行与整个链表“分开”，而这一行元素之间的关系并没有破坏，这样回溯的时候就相当容易，只需反着操作一遍即可。
代码如下：
//删除操作：
template<typename TP>inline void del(TP c)
{
L[R[c]]=L[c],R[L[c]]=R[c];
for(TP i=D[c];i!=c;i=D[i])
for(TP j=R[i];j!=i;j=R[j])
U[D[j]]=U[j],D[U[j]]=D[j];
return;
}
//回溯操作：
template<typename TP>inline void reback(TP c)
{
for(TP i=U[c];i!=c;i=U[i])
for(TP j=L[i];j!=i;j=L[j])
U[D[j]]=D[U[j]]=j;
L[R[c]]=R[L[c]]=c;
return;
}
4.接下来就是整个舞蹈链过程中最美的地方：
template<typename TP>inline bool dancing(TP dep)
{
if(R[0]==0)
{
tot=dep;
return true;
}
TP c=R[0];del(c);
for(TP i=D[c];i!=c;i=D[i])
{
ans[dep]=row[i];//记录答案
for(TP j=R[i];j!=i;j=R[j]) del(col[j]);
if(dancing(dep+1)) return true;
for(TP j=L[i];j!=i;j=L[j]) ret(col[j]);
}
ret(c); //这个地方一定要记得回溯！！
return false;
}
例题：
[LuoguP4929 【模板】舞蹈链（DLX）](https://www.luogu.org/problemnew/show/P4929) 完整代码（建议先自己写一遍再看）： ```cpp #include优化
当然，如果你完全按照上面这么打一定会~TLE（~~hhh~~）这个地方还有一个优化，就是我们在"dancing"过程中，无论用什么方法选择列最终都可以得到解，但有的方法效率明显较高。
为减少迭代次数，我们可以每次都选取1最少的列。
进行这个操作我们只需再定义一个数组s[]
在"push“中加上这样一句：
++s[c];
将"del"部分改成：
U[D[j]]=U[j],D[U[j]]=D[j],--s[col[j]];
将"reback"部分改成：
U[D[j]]=D[U[j]]=j,++s[col[j]];
将"dancing"部分改成：
TP c=R[0];
for(TP i=c;i!=0;i=R[i]) if(s[i]<s[c]) c=i;
del(c);