精确覆盖问题的dancing links 技术

精确覆盖一类的问题，难点在于01矩阵的构造。一旦构造好，就可以用下面的dancing links 技术快速有效地求解。

构造思路：

每个物体所有可能的摆放方式 --行
不重复地覆盖所有格子 -- 目标列
约束条件，或者单个选择的唯一表示 -- 列
把可能的选择，包括已知的选择 --行
比如对于数独问题[2]:
(1)81个格子中每个格子只能放一个数字C1-81
(2)每一行的数字不能重复C82-162
(3)每一列的数字不能重复C163-243
(4)每一九宫内的数字不能重复 C244-324
9,2,0,0,0,0,0,0,0:
9 -- 在1到81列的第一列，在82到162列的第9个，即90列，在163列到243列的第9个，在244到324列的第9个各占一个1
2 -- ...
0 -- 9种选择

以下代码完全参考[1]的做的，打印所有可能的解。当做模板，供以后查询：

/*精确覆盖问题：
   对于一个01矩阵，选择若干行，使得所有1的位置都被覆盖且只被覆盖一次。
X算法：
试探性的选择某一行作为解，
该行覆盖的所有列不用再考虑了，删除；
与该行冲突的哪些行不能选了，删除。
这样原问题的规模缩小，继续在子问题上重复上述过程。
结束条件是目标：所有列都覆盖了。
这里的删除只是临时的，如果选择的行导致最终并没有完全覆盖所有列，
还需要恢复删除的行和列。
这是回溯技术--在搜索树上的深度优先遍历，删除对应标记某些节点不用考虑了。

choose a column c (determin).
choose a row r such that A[r,c] = 1 (non-determin).
include r in the partial solution.
for each j such that A[r,j] = 1,
   delete column j;
   for each i such that A[i,j] = 1, delete row i.
recusively work on the reduced matrix.

例如，对于矩阵，
   C1 C2 C3 C4 C5 C6 C7
   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

从第一列开始，选择
r=2,  j = 4,7, 删除 C4, R2, R4, R6, C7,R2,R5,R6.
剩下C2,C3,C5,C6; R1,R3.
选择C2,只有r=3, j=2,3,6, 删除 C2,R3, C3,R1,R3,C6,R1,R3.
选择C5, 没有行可选来覆盖C5, 回溯到r=2这层，选择r=3,...

只把矩阵中的1连接起来，构成交叉十字循环双向链，
每个元素包含指向左右上下列行的指针。
data object:
 left, right -- link elements of the same row
 up, down -- link elements of the same col
 column -- link to the column header
column header object:
 left, right -- link all columns  not covered
 up, down -- link to first/last elements ot this column
 size -- number of 1s in the column
 name -- name of the column

h -- column header root, only left,right are used.

代码实现：
行没有连表头，处理与列有些不同。
o 构造时；
o 覆盖时， 
  c       C[j]
  | D     |
  r --R-- j
两个地方的cover_column都是针对行r的。
再看看print_solution就知道了，这是
行还没有连表头才这样子写的。
*/
#include <stdio.h>
#define ROW 256
#define COL 256
#define NUM (1+COL+ROW*COL)
static int L[NUM], R[NUM], U[NUM], D[NUM], C[NUM];
static int Y[NUM]; //row link

static int h;
static int S[1+COL]; //number of 1s in the column
static char N[1+COL]; //name of columns

static int row, col; //actual row and col number
static int O[ROW]; //choosed rows, partial solution

void cover_column(int c)
{
	int i, j;
	L[R[c]] = L[c]; R[L[c]] = R[c];//delete column c 
	for(i = D[c]; i != c; i = D[i]){
		for(j = R[i]; j != i; j = R[j]){//delete row i
			U[D[j]] = U[j]; D[U[j]] = D[j];
			S[C[j]]--;	
		}
	}
}

void uncover_column(int c)
{
	int i, j;
	for(i = U[c]; i != c; i = U[i]){
		for(j = L[i]; j != i; j = L[j]){
			S[C[j]]++;
			U[D[j]] = j; D[U[j]] = j;
		}
	}
	L[R[c]] = c; R[L[c]] = c;
}

void print_solution(int k)
{
	int i, j, r;
	for(i = 0; i < k; ++i){
		r = O[i];
		printf("row %d: col %c ", Y[r], N[C[r]]);
		for(j = R[r]; j != r; j = R[j]){//?
			printf("%c ", N[C[j]]);
		}
		printf("\n");
	}
	printf("===using %d rows\n", k);
}

int choose_column(void)
{
	int c, s, j;
	c = R[h];
	s = S[c];//select smallest branching factor
	for(j = R[c]; j != h; j = R[j]){
		if(S[j] < s){
			c = j; s = S[j];
		}
	}
	return c;
}


void search(int k)
{
	int c, r, j;
	if(R[h] == h){
		print_solution(k);
		return;
	}
	c = choose_column();
	cover_column(c);
	for(r = D[c]; r != c; r = D[r]){
		O[k] = r;
		for(j = R[r]; j != r; j = R[j]){
			cover_column(C[j]);
		}
		search(k+1);

		for(j = L[r]; j != r; j = L[j]){
			uncover_column(C[j]);
		}
	}
	uncover_column(c);
}

void insert_column(int x, int c)
{
	C[x] = c;
	D[x] = c; U[x] = U[c];
	U[D[x]] = x; D[U[x]] = x;
	S[c]++;
}

void insert_row(int x, int r)
{
	R[x] = r; L[x] = L[r];
	L[R[x]] = x; R[L[x]] = x;
}

int main()
{
	int i, j, val, loc, rlo;

	scanf("%d%d", &row, &col);
	h = 0;
	L[h] = col; R[h] = 1;
	for(i = 1; i <= col; ++i){
		L[i] = i-1; R[i] = i < col ? i+1 : h; U[i] = D[i] = i;
		C[i] = 0; S[i] = 0; N[i] = 'A' + i-1;
	}
	loc = col;

	for(j = 0; j < row; ++j){
		rlo = 0;
		for(i = 0; i < col; ++i){
			scanf("%d", &val);
			if(val){
				++loc;
				insert_column(loc, 1+i);
				
				Y[loc] = j+1;
				if(!rlo){
					rlo = loc;
					L[loc] = R[loc] = loc;
				}else{
					insert_row(loc, rlo);
				}	
			}
		}
	}

	search(0);
	return 0;
}

[1] dancing links, http://arxiv.org/pdf/cs/0011047.pdf
[2] http://blog.csdn.net/mu399/article/details/7627862