这两天打算做个数独玩玩，查了一下解数独最好的算法叫舞蹈链：Dance Link X

该算法主要是解决精确覆盖问题：比如有个集合X，以及其若干子集的集合Y，要求出一个Y的子集Y*，能够恰好分割X。

举个例子，有集合X = [1,2,3,4,5,6,7]，以及其子集的集合Y：

集合1：[3,5,6]

集合2：[1,4,7]

集合3：[2,3,6]

集合4：[1,4]

集合5：[2,7]

集合6：[4,5,6]

要从Y的集合中选则若干集合，能够刚好覆盖X，每个元素出现且只出现一次。由上面的例子可知集合1,4,5所包含的元素能满足要求

舞蹈链算法也就是用来解决上述问题的，不过说这个是算法，倒是更像一种数据结构，因为首先解决问题之前需要构建一个链表，如下所示：

该链表的名称叫做：双向 十字 交叉 循环 链表，看起来就是很高端很霸气的名字，就像龙母的称谓一样：丹妮莉丝 坦格利安，旧瓦雷利亚的后裔，安达尔人先民的女王，维斯特洛的统治者暨全境守护者，大草原多斯拉克人卡丽熙，不焚者，弥林的女王，镣拷打破者，龙之母，豌豆射手，阿斯塔波的解放者，罗伊拿人和先民的女王，龙石岛公主

扯远了，简单解释一下，双向不用说，十字交叉一看就明白，这个链表的每一行每一列都是收尾相连的(Head不算)，也就是循环的。

该链表的每个节点有六个属性，分别指向上下左右以及列节点，还有行号。

class CrossCycleLinkNode(object):

def __init__(self, x, row):

self.val = x

self.row = row

self.col = self

self.up = self

self.down = self

self.left = self

self.right = self

现在介绍一下算法的主要步骤，以及实现的函数：

def dance_link_x(head: CrossCycleLinkNode, answers: list):

head是头结点，answers是装答案(行号)的列表

从head的右边第一个节点(first_col)入手，将这一列的所有节点从链表中移除，并将恢复的操作压入栈中：

restores = []

first_col = head.right

first_col.removeColumn()

restores.append(first_col.restoreColumn)

上面的removeColumn和restoreColumn是一对作用相反的CrossCycleLinkNode成员方法，用来移除(或恢复)该节点所在的列上面的所有节点(移除或恢复行也有)：

class CrossCycleLinkNode(object):

def removeColumn(self):

node = self

while True:

node.left.right = node.right

node.right.left = node.left

node = node.down

if node == self: break

pass

def restoreColumn(self):

node = self

while True:

node.left.right = node

node.right.left = node

node = node.down

if node == self: break

pass

def removeRow(self):

node = self

while True:

node.up.down = node.down

node.down.up = node.up

node = node.right

if node == self: break

pass

def restoreRow(self):

node =self

while True:

node.up.down = node

node.down.up = node

node = node.right

if node == self: break

pass

注意看代码，这仅仅改变了周边结点的指向，结点自身的指向还是没变的

如上图所示，first_col所在的列从链表中移除后，该列的节点仍然指向原来的地方，所以restores弹出恢复方法的时候调用就可以恢复到移除之前的样子

再往下走，遍历first_col上所有结点，将结点所在的行也从链表中移除(列节点除外)，并且将恢复操作入栈

node = first_col.down

while node != first_col:

if node.right != node:

node.right.removeRow()

restores.append(node.right.restoreRow)

node = node.down

如果该节点所在行只有它自己则跳过，而且要从该节点的右(或左)节点调用移除方法，不能直接从该节点上调用，不然会死循环

上图是把节点4所在行移除后的样子

将节点10所在行移除后如上图所示

可以确定答案很定在4节点或10节点所在行的其中之一(如果答案存在)

所以轮流对4节点及10节点的行进行遍历，首先是4节点。先保存现在的restores栈的数量，因为如果4节点不在正确答案里的话，则需要对后面的移除进行恢复操作。并将4节点的行号加到answers中

cur_restores_count = len(restores)

selected_row = first_col.down

while selected_row != first_col:

answers.append(selected_row.row)

'''在这里进行后续操作'''

if dance_link_x(head, answers):

while len(restores): restores.pop()()

return True

answers.pop()

while len(restores) > cur_restores_count: restores.pop()()

selected_row = selected_row.down

可以看到上面的代码中间空了一部分，这里的意思是一顿操作后进行递归，如果递归的结果是返回True则说明找到了符合要求的答案，则恢复所有移除的节点，然后继续返回True，这里直接返回也可以，但是万一下次还要用这个链表就尴尬了，所有顺手给他恢复了

若果是False，说明4节点的行不在答案中，所以把4节点的行号从answers中弹出，并恢复到之前的链表。

下面详细说一下上面一顿操作的步骤

从4节点右边的第一个节点开始(5节点)，对4节点所在行的节点进行遍历(不包括4节点)，找到该节点的列节点，调用removeColumn，将该列从链表中移除

if selected_row.right != selected_row:

row_node = selected_row.right

while True:

col_node = row_node.col

col_node.removeColumn()

restores.append(col_node.restoreColumn)

'''这部分看后面'''

row_node = row_node.right

if row_node == selected_row.right: break

效果如下图所示：

接着又从该列节点往下，遍历列节点除外的每一个节点，并调用removeRow(如果节点所在行只有它一个就跳过)

col_node = col_node.down

while col_node != col_node.col:

if col_node.right != col_node:

col_node.right.removeRow()

restores.append(col_node.right.restoreRow)

col_node = col_node.down

下图是把C4列节点下面的14节点所在的行从链表中移除

再往下走没有更多节点了，又回到了C4节点，于是回到5节点，找到它的右一个节点：6节点。并重复上面的操作，先找点列节点C7，调用removeColumn，移除整列

然后从C7往下找，发现13节点所在行还有其他节点，将13节点所在行整航移除

回到6节点，再往右，发现遍历完毕，将被移除的节点从图中隐藏，整个链表如下所示：

然后就是之前所说的，对该链表进行递归，递归的结果如果是True则找到了答案，False则进行下一个尝试(10节点)，如果都没有找到答案，这说明此种情况没有复合要求的解，全部恢复，返回False

while len(restores): restores.pop()()

return False

还有就是，递归的话就需要在函数的开头进行检查，所以回到函数的开始位置

首先检查Head节点的右(或左)节点是否指向自身，如果是则说明所有列已经被覆盖，返回True，否则说明还有列没有被覆盖

def dance_link_x(head: CrossCycleLinkNode, answers: list):

if head.right == head:

return True

接着要检查的就是是否有列节点的上(下)节点指向自身，如果有说明现在的情况无法得到复合要求的答案，直接return False

node = head.right

while True:

if node.down == node: return False

node = node.right

if node == head: break

以上就是每一步的详细过程，下面吧完整的代码贴出来：

def dance_link_x(head: CrossCycleLinkNode, answers: list):

if head.right == head: return True

node = head.right

while node != head:

if node.down == node: return False

node = node.right

restores = []

first_col = head.right

first_col.removeColumn()

restores.append(first_col.restoreColumn)

node = first_col.down

while node != first_col:

if node.right != node:

node.right.removeRow()

restores.append(node.right.restoreRow)

node = node.down

cur_restores_count = len(restores)

selected_row = first_col.down

while selected_row != first_col:

answers.append(selected_row.row)

if selected_row.right != selected_row:

row_node = selected_row.right

while True:

col_node = row_node.col

col_node.removeColumn()

restores.append(col_node.restoreColumn)

col_node = col_node.down

while col_node != col_node.col:

if col_node.right != col_node:

col_node.right.removeRow()

restores.append(col_node.right.restoreRow)

col_node = col_node.down

row_node = row_node.right

if row_node == selected_row.right: break

if dance_link_x(head, answers):

#while len(restores): restores.pop()()

return True

answers.pop()

while len(restores) > cur_restores_count: restores.pop()()

selected_row = selected_row.down

while len(restores): restores.pop()()

return False

下面是一初始化链表的辅助函数，也贴出来

def initCol(col_count: int):

head = CrossCycleLinkNode('head', 'column')

for i in range(col_count):

col_node = CrossCycleLinkNode(x=i, row=head.row)

col_node.right = head

col_node.left = head.left

col_node.right.left = col_node

col_node.left.right = col_node

return head

def appendRow(head: CrossCycleLinkNode, row_id: int, nums: list):

last = None

col = head.right

for num in nums:

while col != head:

if col.val == num:

node = CrossCycleLinkNode(1, row_id)

node.col = col

node.down = col

node.up = col.up

node.down.up = node

node.up.down = node

if last is not None:

node.left = last

node.right = last.right

node.left.right = node

node.right.left = node

last = node

break

col = col.right

else:

return