dancing links解决X问题的C++实现

X问题，也称精确覆盖问题，就是给定一个01矩阵，需要从中选取一些行组成一个子矩阵，这个子矩阵的每一列有且仅有一个1。这个问题听起来就知道很难，必须使用回溯算法来解决，但是我们知道回溯算法要提高效率，就必须做好剪枝和回溯恢复的工作。这时算法大师Donald E.Knoth给出了一个巧妙的数据结构，十字链表，每个节点都有上下左右的指针。其实这个结构参考的是双链表删除和恢复的便利性，思考一下，在双链表中，删除一个节点的代码就是n->left->right=n->right; n->right->left=n->left，而撤销删除的代码就是n->left->right=n; n->right->left=n;这几乎不需要任何代价就能解决。举个例子，一个如下的01矩阵

board.push_back("0010110");
board.push_back("1001001");
board.push_back("0110010");
board.push_back("1001000");
board.push_back("0100001");
board.push_back("0001101");

利用十字链表就表示如下：

其中第一行是特殊的节点，我们可以称为列节点，第一个是头节点，他们都是不存储数据，然后其他节点就是矩阵中的1，为了调试方便，把它们的节点数据都写为节点序号，说了那么多，都忘记给出节点的数据结构了：

struct Cell{
	Cell* up,*down,*left,*right;
	Cell* col;
	int rowIndex;
	Cell(int r):up(NULL),down(NULL),left(NULL),right(NULL),col(NULL),rowIndex(r){}
};

细心的读者肯定会发现，节点结构中除了上下左右指针外，还有一个col指针，没错，这个是指向每一列的列节点的指针。说了这里，也应该开始讲算法思路了，

1.取出nextCell=head->right，如果nextCell等于head，则算法结束，返回答案，否则进入第2步。

2.删除nextCell，遍历nextCell下面的所有节点，将这些节点所在的行都删除。

3.取出downCell=nextCell->down，如果downCell等于nextCell，则代表不能继续搜索，需要回溯，进入第5步，否则进入第4步。

4.遍历downCell右边的所有节点，将每个节点的列节点都按照第2步的方法删除，然后重新进入第1步。

5.回溯恢复到删除downCell所有右节点的列节点的状态，然后downCell=downCell->down，如果downCell等于nextCell，证明也不能回溯了，需要恢复nextCell，继续返回上一级恢复，否则进入第4步。

算法的思路就只有这么多了，其中恢复节点看上去很难，但只要按照删除的顺序逆回去，堆栈就会很好地帮你实现了。具体删除和恢复的代码如下：

bool removeColCell(Cell* colCell){
	colCell->left->right=colCell->right;
	colCell->right->left=colCell->left;
	Cell* downCell=colCell->down;
	if(downCell==colCell)
		return false;
	while(downCell!=colCell){
		Cell* downRightCell=downCell->right;
		while(downRightCell!=downCell){
			downRightCell->up->down=downRightCell->down;
			downRightCell->down->up=downRightCell->up;
			downRightCell=downRightCell->right;
		}
		downCell=downCell->down;
	}
	return true;
}
void recoverColCell(Cell* colCell){
	Cell* downCell=colCell->down;
	while(downCell!=colCell){
		Cell* downRightCell=downCell->right;
		while(downRightCell!=downCell){
			downRightCell->up->down=downRightCell;
			downRightCell->down->up=downRightCell;
			downRightCell=downRightCell->right;
		}
		downCell=downCell->down;
	}
	colCell->left->right=colCell;
	colCell->right->left=colCell;
}

DLX算法主体代码如下：

bool solveWithDLX(Cell* head,vector<int>& answers){
	if(head->right==head)
		return true;
	Cell* nextCell=head->right;
	if(!removeColCell(nextCell))
		return false;
	Cell* downCell=nextCell->down;
	while(downCell!=nextCell){
		Cell* downRightCell=downCell->right;
		while(downRightCell!=downCell){
			Cell* rightColCell=downRightCell->col;
			removeColCell(rightColCell);
			downRightCell=downRightCell->right;
		}
		if(solveWithDLX(head,answers)){
			answers.push_back(downCell->rowIndex);
			return true;
		}else{
			Cell* downRightCell=downCell->right;
			while(downRightCell!=downCell){
				Cell* rightColCell=downRightCell->col;
				recoverColCell(rightColCell);
				downRightCell=downRightCell->right;
			}
			downCell=downCell->down;
		}
	}
	recoverColCell(nextCell);
	return false;
}

然后构建十字链表的代码如下：

	vector<string> board;
	board.push_back("0010110");
	board.push_back("1001001");
	board.push_back("0110010");
	board.push_back("1001000");
	board.push_back("0100001");
	board.push_back("0001101");
	Cell* head=new Cell(0);
	Cell* lastCell=head;
	vector<Cell*> columnCells;
	for(int i=0;i<7;i++){
		Cell* cell=new Cell(-1-i);
		lastCell->right=cell;
		cell->left=lastCell;
		cell->up=cell;
		cell->down=cell;
		columnCells.push_back(cell);
		lastCell=cell;
	}
	lastCell->right=head;
	head->left=lastCell;
	int index=1;
	for(int i=0;i<board.size();i++){
		Cell *lastCell=NULL,*firstCell=NULL;
		for(int j=0;j<board[i].length();j++){
			if(board[i][j]=='1'){
				Cell* columnCell=columnCells[j];
				Cell* cell=new Cell(i+1);
				cell->up=columnCell->up;
				cell->down=columnCell;
				columnCell->up->down=cell;
				columnCell->up=cell;
				cell->col=columnCell;
				if(lastCell==NULL){
					firstCell=cell;
					lastCell=cell;
				}
				cell->left=lastCell;
				lastCell->right=cell;
				lastCell=cell;
			}
		}
		firstCell->left=lastCell;
		lastCell->right=firstCell;
	}
	vector<int>answers;
	solveWithDLX(head,answers);
	for(int i=0;i<answers.size();i++){
		cout<<answers[i]<<endl;
	}

最终代码会输出选择的行号。

最后的最后，虽然上面的代码解决一般的X问题没问题，但是当我将数独问题转化成X问题时，再用DLX算法却始终没跑出来，还请各位大神帮忙看一眼，其中删除和恢复的代码都是一样的，只是构建十字链表不太一样，这个十字链表一共有324列，也就是81*4，第一个81是代表81个格子中第几个格子有数，第二个81是代表第几行有哪个数字，第三个81是代表第几列有哪个数字，第四列是代表第几个九宫格有哪个数字，举个例子，如果第2个格子是9，那么在十字链表中将插入一行，这一行在第1列是1，第81+8列是1，第81*2+9+8列是1，以及第81*3+8列是1，而如果第2个格子是空的，那么这个格子会有9种可能，所以会插入9行，第0行中第1列是1，第81+0列是1，第81*2+9+0列是1，第81*3+0是1，其他行也如此类推。代码如下：

void solveSudoku(vector<vector<char>>& board) {
	Cell* head=new Cell(0);
	Cell* lastCell=head;
	vector<Cell*> columnCells;
	for(int i=0;i<324;i++){
		Cell* cell=new Cell(-i-1);
		cell->up=cell;
		cell->down=cell;
		lastCell->right=cell;
		cell->left=lastCell;
		columnCells.push_back(cell);
		lastCell=cell;
	}
	lastCell->right=head;
	head->left=lastCell;
	for(int i=0;i<9;i++){
		for(int j=0;j<9;j++){
			if(board[i][j]!='.'){
				int num=board[i][j]-'1';
				int rowIndex=(i*9+j)*10+num;
				Cell* posCell=new Cell(rowIndex);
				Cell* posColumnCell=columnCells[i*9+j];
				posCell->up=posColumnCell->up;
				posCell->down=posColumnCell;
				posColumnCell->up->down=posCell;
				posColumnCell->up=posCell;
				posCell->col=posColumnCell;

				Cell* rowCell=new Cell(rowIndex);
				rowCell->left=posCell;
				posCell->right=rowCell;
				Cell* rowColumnCell=columnCells[i*9+num+81];
				rowCell->up=rowColumnCell->up;
				rowCell->down=rowColumnCell;
				rowColumnCell->up->down=rowCell;
				rowColumnCell->up=rowCell;
				rowCell->col=rowColumnCell;

				Cell* colCell=new Cell(rowIndex);
				colCell->left=rowCell;
				rowCell->right=colCell;
				Cell* colColumnCell=columnCells[j*9+num+81*2];
				colCell->up=colColumnCell->up;
				colCell->down=colColumnCell;
				colColumnCell->up->down=colCell;
				colColumnCell->up=colCell;
				colCell->col=colColumnCell;

				Cell* subCell=new Cell(rowIndex);
				subCell->left=colCell;
				subCell->right=posCell;
				posCell->left=subCell;
				colCell->right=subCell;
				int subIndex=i/3*3+j/3;
				Cell* subColumnCell=columnCells[subIndex*9+num+81*3];
				subCell->up=subColumnCell->up;
				subCell->down=subColumnCell;
				subColumnCell->up->down=subCell;
				subColumnCell->up=subCell;
				subCell->col=subColumnCell;
			}else{
				for(int num=0;num<9;num++){
					int rowIndex=(i*9+j)*10+num;
					Cell* posCell=new Cell(rowIndex);
					Cell* posColumnCell=columnCells[i*9+j];
					posCell->up=posColumnCell->up;
					posCell->down=posColumnCell;
					posColumnCell->up->down=posCell;
					posColumnCell->up=posCell;
					posCell->col=posColumnCell;

					Cell* rowCell=new Cell(rowIndex);
					rowCell->left=posCell;
					posCell->right=rowCell;
					Cell* rowColumnCell=columnCells[i*9+num+81];
					rowCell->up=rowColumnCell->up;
					rowCell->down=rowColumnCell;
					rowColumnCell->up->down=rowCell;
					rowColumnCell->up=rowCell;
					rowCell->col=rowColumnCell;

					Cell* colCell=new Cell(rowIndex);
					colCell->left=rowCell;
					rowCell->right=colCell;
					Cell* colColumnCell=columnCells[j*9+num+81*2];
					colCell->up=colColumnCell->up;
					colCell->down=colColumnCell;
					colColumnCell->up->down=colCell;
					colColumnCell->up=colCell;
					colCell->col=colColumnCell;

					Cell* subCell=new Cell(rowIndex);
					subCell->left=colCell;
					subCell->right=posCell;
					posCell->left=subCell;
					colCell->right=subCell;
					int subIndex=i/3*3+j/3;
					Cell* subColumnCell=columnCells[subIndex*9+num+81*3];
					subCell->up=subColumnCell->up;
					subCell->down=subColumnCell;
					subColumnCell->up->down=subCell;
					subColumnCell->up=subCell;
					subCell->col=subColumnCell;
				}
			}
		}
	}
	vector<int> answers;
	solveWithDLX(head,answers);
	for(int i=0;i<answers.size();i++){
		int rowIndex=answers[i];
		int val=rowIndex%10;
		rowIndex/=10;
		int row=rowIndex/9;
		int col=rowIndex%9;
		if(board[row][col]=='.')
			board[row][col]=val+'1';
	}
}

细心的读者肯定发现，每个节点的数据存的都是行号*9+列号+num，这样我通过最后的answer就知道该在哪个格子中填什么数字。不过这些都不重要，现在是这代码好像进入了死循环，每次跑都会报出栈溢出，恳求大神们看看是不是构建矩阵时出错了。

鸣谢http://www.cnblogs.com/grenet/p/3145800.html给出了大量的图和详细的讲解。