标签：
hiho一下第102周的题目。
原题地址：http://hihocoder.com/problemset/problem/1321
题意：输入一个9*9数独矩阵，0表示没填的空位，输出这个数独的答案。
提示已经讲解的很清楚了。稍微整理下思路。最后附AC代码。
一、Dancing Links解决精确覆盖问题。
1.精确覆盖问题
给定一个n行，m列的01矩阵。从中选择若干行使得每一列有且恰好只有一个1。
例如：
答案是选择2，3，4行。
2.DancingLinks求解精确覆盖问题
精确覆盖问题：从01矩阵中选择若干行使得每一列有且恰好只有一个1。
简单来说
精确覆盖问题的算法就是利用DFS搜索。
先选择一行，将当前覆盖的列以及能够覆盖到该列的所有行全部去掉，形成新的小规模的矩阵。
然后再逐行枚举，添加新的要覆盖的列，删除相应的行和列，重复直到剩下的矩阵只有1行。
如果剩下最后一行都是1，问题就解决了。
如果剩下最后一行还有0，则存在某些列没有被覆盖到。
DFS回溯求解。
而DancingLinks其实是一种数据结构。
不懂DangcingLinks的戳这里：http://www.cnblogs.com/grenet/p/3145800.html
DancingLinks模板（真不记得从哪里抄的）：
/********************************************************************************* DLX模板 精确覆盖（exact_） 重复覆盖（repeat_） **********************************************************************************/ struct DLX { int n,m,SIZE; int U[maxnode],D[maxnode],R[maxnode],L[maxnode],Row[maxnode],Col[maxnode];//L,R,D,U四个数组记录某节点上下左右邻居 int H[MaxN], S[MaxM];//H记录排头，S记录某列有多少个节点 int ansd, ans[MaxN]; void init(int _n,int _m) { n = _n; m = _m; for(int i = 0;i <= m;i++) { S[i] = 0; U[i] = D[i] = i; L[i] = i-1; R[i] = i+1; } R[m] = 0; L[0] = m; SIZE = m; for(int i = 1;i <= n;i++) H[i] = -1; } void Link(int r,int c) { ++S[Col[++SIZE]=c]; Row[SIZE] = r; D[SIZE] = D[c]; U[D[c]] = SIZE; U[SIZE] = c; D[c] = SIZE; if(H[r] < 0)H[r] = L[SIZE] = R[SIZE] = SIZE; else { R[SIZE] = R[H[r]]; L[R[H[r]]] = SIZE; L[SIZE] = H[r]; R[H[r]] = SIZE; } } void exact_Remove(int c) { L[R[c]] = L[c]; R[L[c]] = R[c]; for(int i = D[c];i != c;i = D[i]) for(int j = R[i];j != i;j = R[j]) { U[D[j]] = U[j]; D[U[j]] = D[j]; --S[Col[j]]; } } void repeat_remove(int c) { for(int i = D[c]; i != c; i = D[i]) L[R[i]] = L[i], R[L[i]] = R[i]; } void repeat_resume(int c) { for(int i = U[c]; i != c; i = U[i]) L[R[i]] = R[L[i]] = i; } int f() { //估价函数。 bool vv[MaxM]; int ret = 0, c, i, j; for(c = R[0]; c != 0; c = R[c]) vv[c] = 1; for(c = R[0]; c != 0; c = R[c]) if(vv[c]) { ++ret, vv[c] = 0; for(i = D[c]; i != c; i = D[i]) for(j = R[i]; j != i; j = R[j]) vv[Col[j]] = 0; } return ret; } void repeat_dance(int d) { if(d + f() >= ansd) return; //估价函数剪枝，A*搜索 if(R[0] == 0) { if(d < ansd) ansd = d; return; } int c = R[0], i, j; for(i = R[0]; i; i = R[i]) if(S[i] < S[c]) c = i; for(i = D[c]; i != c; i = D[i]) { repeat_remove(i); for(j = R[i]; j != i; j = R[j]) repeat_remove(j); repeat_dance(d + 1); for(j = L[i]; j != i; j = L[j]) repeat_resume(j); repeat_resume(i); } } void exact_resume(int c) { for(int i = U[c];i != c;i = U[i]) for(int j = L[i];j != i;j = L[j]) ++S[Col[U[D[j]]=D[U[j]]=j]]; L[R[c]] = R[L[c]] = c; } //d为递归深度 bool exact_Dance(int d) { if(R[0] == 0) { ansd = d; return true; } int c = R[0]; for(int i = R[0];i != 0;i = R[i]) if(S[i] < S[c]) c = i; exact_Remove(c); for(int i = D[c];i != c;i = D[i]) { ans[d] = Row[i]; for(int j = R[i]; j != i;j = R[j]) exact_Remove(Col[j]); if(exact_Dance(d+1))return true; for(int j = L[i]; j != i;j = L[j]) exact_resume(Col[j]); } exact_resume(c); return false; } }; /*********************************************************************************** 模板结束 ***********************************************************************************/
二、把一个数独问题转化为精确覆盖问题。
1.数独问题
给定一个9x9的矩阵。将1~9填入当中。其中有些格子已经填好了，有些格子则需要你填进去。
对于填好后的矩阵，需要满足3个条件：
例如：
输入格式：数独9*9矩阵，0表示该格未填写数字，1~9表示该格已经填写有该数字。
样例输入：
4 0 0 0 7 0 1 0 0
0 0 1 9 0 4 6 0 5
0 0 0 0 0 1 0 0 0
0 0 0 7 0 0 0 0 2
0 0 2 0 3 0 0 0 0
8 4 7 0 0 6 0 0 0
0 1 4 0 0 0 8 0 6
0 2 0 0 0 0 3 0 0
6 0 0 0 9 0 0 0 0
2.如何把数独问题表示为精确覆盖问题
即 把数独矩阵转化为01覆盖矩阵。
对于精确覆盖问题的01矩阵，其行与列的意义：
精确覆盖的结果 选取若干个方案，每个方案可以满足一个或多个约束条件，每个条件恰被其中一个方案满足。
考虑数独问题的约束条件和方案。
约束条件：
1.每一个数字在每一行出现。
由于行和数字的互相匹配，因此一共会产生9x9，81个约束条件 。
1. 第1行存在数字1
2. 第1行存在数字2
3. 第1行存在数字3 ...
9. 第1行存在数字9
10. 第2行存在数字1
11. 第2行存在数字2 ...
18. 第2行存在数字9
19. 第3行存在数字1 ...
80. 第9行存在数字8
81. 第9行存在数字9
对于第 i 行第 j 列填写数字 k 时，其对应的列序号为 (i-1)*9+k
2.每一个数字在每一列出现。
由于列和数字的互相匹配，因此一共会产生9x9，81个约束条件：
第 i 列存在数字 j。 （i=1~9， j=1~9）
对于第 i 行第 j 列填写数字 k 时，其对应的列序号为 81+(j-1)*9+k
3.每一个数字在每一个九宫出现。
由于九宫和数字的互相匹配，因此一共会产生9x9，81个约束条件：
第 i 个九宫格存在数字 j。 （i=1~9， j=1~9）
对于第 i 行第 j 列填写数字 k 时，位于第t个九宫，其对应的约束条件序号为 162+(t-1)*9+k，
其中 t = ((i - 1) / 3 * 3 + (j - 1) / 3) + 1;
4.每一个格子填了一个数字
由于格子和数字的互相匹配，因此一共会产生9x9，81个约束条件：
格子（i，j）填了数字。
对于 第 i 行第 j 列填写数字 k 时，其对应的约束条件序号为243+(i-1)*9+j
合计9*9*4=324个约束条件，对应的01矩阵有324列。
方案：
每一个格子可能填1-9这 9 个数字，一共有81个格子，总共是729个方案。
方案 “第 i 行第 j 列填写数字 k” 对应的行序号(方案编号)为 (（（i-1)*9+j）-1）*9+k
合计9*9*9=729个方案，对应的01矩阵有729行。
由此，9*9的数独问题转化为729*324的01矩阵的精确覆盖的问题。
转化成01矩阵的代码：
char s[10][10]; //原数独矩阵 void setmx(int i,int j,int k){ //方案“第i行第j列填写数字k” int id = (i - 1) * 9 + j ;// 表示第i行第j列格子的编号 int pid = (id - 1) * 9 + k; // 表示该格子填写k所对应的方案编号 // 约束条件1 - 对应第1~81列 // 第(i-1)*9+k列表示第i行存在数字k dlx.Link(pid,(i - 1) * 9 + k); //01矩阵(pid,(i - 1) * 9 + k)置1 // 约束条件2 - 对应第82~162列 // 第81+(j-1)*9+k列表示第j列存在数字k dlx.Link(pid,81 + (j - 1) * 9 + k); //01矩阵(pid,81 + (j - 1) * 9 + k)置1 // 约束条件3 - 对应第163~243列 // 第162+(t-1)*9+k列表示第t个九宫存在数字k int t = ((i - 1) / 3 * 3 + (j - 1) / 3) + 1; dlx.Link(pid,162 + (t - 1) * 9 + k); //01矩阵(pid,162 + (t - 1) * 9 + k)置1 // 约束条件4 - 对应第244~324列 // 第243+id列表示第i行第j列填写有数字 dlx.Link(pid,243 + id); //01矩阵(pid,243 + id)置1 } void set_board() //把原数独转化成729*324的01矩阵 { int i,j,k; for(i = 1; i <= 9; i++){ for(j = 1; j <= 9; j++){ if(s[i][j] == ‘0‘){ //位置(i,j)值不确定，可以为1~9 for(k = 1; k <= 9; k++){ //枚举可能的数字 setmx(i,j,k); } } else{ //位置(i,j)值确定为k k = s[i][j] - ‘0‘; setmx(i,j,k); } } } }
3.由精确覆盖问题答案得到原数独问题的答案
精确覆盖的结果 选取若干个方案，每个方案可以满足一个或多个约束条件，每个条件恰被其中一个方案满足。
对应数独矩阵的意义
每个条件恰被其中一个方案满足：
约束条件1 “第1行存在数字1” 恰被一个方案满足，即“第一行存在且仅存在一个数字1”。
约束条件2 “第1行存在数字2” 恰被一个方案满足，即“第一行存在且仅存在一个数字2”。
……
约束条件324 “格子（9，9）填了数字” 恰被一个方案满足，即“格子（9，9）填了并仅填了一个数字”。
729*324的01矩阵的精确覆盖 满足了9*9的数独填完的所有约束条件。
而选取若干个方案：
方案一 “第 i1 行第 j1 列填写数字 k1”
方案二 “第 i2 行第 j2 列填写数字 k2”
……
选取的所有方案就是数独的答案。
对于每个方案, 第 i 行第 j 列填写数字 k
全部方案填入数独矩阵即为数独的答案。
精确覆盖答案还原成数独答案：
选取的方案即 01矩阵选择的行，利用DangcingLinks求解。
数组ans[]记录 01矩阵选取的行序号，ansd表示选择的行总数。
行序号 pid = (((i - 1) * 9 + j)-1)+k，得到行序号 pid 即可还原（i，j, k）的值，即得到方案 “第 i 行第 j 列填写数字 k”。
#1321 AC代码：
#include <algorithm> #include <cstring> #include <string.h> #include <iostream> #include <list> #include <map> #include <set> #include <stack> #include <string> #include <utility> #include <queue> #include <vector> #include <cstdio> #include <cmath> #define LL long long using namespace std; /************************************************************************************ DLX模板 精确覆盖（exact_） 重复覆盖（repeat_） ************************************************************************************/ const int maxnode = 2361960+105; const int MaxM = 324+10; //01矩阵列数 const int MaxN = 729+10; //01矩阵行数 struct DLX { int n,m,SIZE; int U[maxnode],D[maxnode],R[maxnode],L[maxnode],Row[maxnode],Col[maxnode];//L,R,D,U四个数组记录某节点上下左右邻居 int H[MaxN], S[MaxM];//H记录排头，S记录某列有多少个节点 int ansd, ans[MaxN]; void init(int _n,int _m) { n = _n; m = _m; for(int i = 0;i <= m;i++) { S[i] = 0; U[i] = D[i] = i; L[i] = i-1; R[i] = i+1; } R[m] = 0; L[0] = m; SIZE = m; for(int i = 1;i <= n;i++) H[i] = -1; } void Link(int r,int c) { ++S[Col[++SIZE]=c]; Row[SIZE] = r; D[SIZE] = D[c]; U[D[c]] = SIZE; U[SIZE] = c; D[c] = SIZE; if(H[r] < 0)H[r] = L[SIZE] = R[SIZE] = SIZE; else { R[SIZE] = R[H[r]]; L[R[H[r]]] = SIZE; L[SIZE] = H[r]; R[H[r]] = SIZE; } } void exact_Remove(int c) { L[R[c]] = L[c]; R[L[c]] = R[c]; for(int i = D[c];i != c;i = D[i]) for(int j = R[i];j != i;j = R[j]) { U[D[j]] = U[j]; D[U[j]] = D[j]; --S[Col[j]]; } } void repeat_remove(int c) { for(int i = D[c]; i != c; i = D[i]) L[R[i]] = L[i], R[L[i]] = R[i]; } void repeat_resume(int c) { for(int i = U[c]; i != c; i = U[i]) L[R[i]] = R[L[i]] = i; } int f() { //估价函数。 bool vv[MaxM]; int ret = 0, c, i, j; for(c = R[0]; c != 0; c = R[c]) vv[c] = 1; for(c = R[0]; c != 0; c = R[c]) if(vv[c]) { ++ret, vv[c] = 0; for(i = D[c]; i != c; i = D[i]) for(j = R[i]; j != i; j = R[j]) vv[Col[j]] = 0; } return ret; } void repeat_dance(int d) { if(d + f() >= ansd) return; //估价函数剪枝，A*搜索 if(R[0] == 0) { if(d < ansd) ansd = d; return; } int c = R[0], i, j; for(i = R[0]; i; i = R[i]) if(S[i] < S[c]) c = i; for(i = D[c]; i != c; i = D[i]) { repeat_remove(i); for(j = R[i]; j != i; j = R[j]) repeat_remove(j); repeat_dance(d + 1); for(j = L[i]; j != i; j = L[j]) repeat_resume(j); repeat_resume(i); } } void exact_resume(int c) { for(int i = U[c];i != c;i = U[i]) for(int j = L[i];j != i;j = L[j]) ++S[Col[U[D[j]]=D[U[j]]=j]]; L[R[c]] = R[L[c]] = c; } //d为递归深度 bool exact_Dance(int d) { if(R[0] == 0) { ansd = d; return true; } int c = R[0]; for(int i = R[0];i != 0;i = R[i]) if(S[i] < S[c]) c = i; exact_Remove(c); for(int i = D[c];i != c;i = D[i]) { ans[d] = Row[i]; for(int j = R[i]; j != i;j = R[j]) exact_Remove(Col[j]); if(exact_Dance(d+1))return true; for(int j = L[i]; j != i;j = L[j]) exact_resume(Col[j]); } exact_resume(c); return false; } }; /*********************************************************************************** 模板结束 **********************************************************************************/
DLX dlx; char s[12][12]; //原数独矩阵 void setmx(int i,int j,int k){ int id = (i - 1) * 9 + j ;// 表示第i行第j列格子的编号 int pid = (id - 1) * 9 + k; // 表示该格子填写k所对应的方案编号 // 约束条件1 - 对应第1~81列 // 第(i-1)*9+k列表示第i行存在数字k dlx.Link(pid,(i - 1) * 9 + k); // 约束条件2 - 对应第82~162列 // 第81+(j-1)*9+k列表示第j列存在数字k dlx.Link(pid,81 + (j - 1) * 9 + k); // 约束条件3 - 对应第163~243列 // 第162+(t-1)*9+k列表示第t个九宫存在数字k int t = ((i - 1) / 3 * 3 + (j - 1) / 3) + 1; dlx.Link(pid,162 + (t - 1) * 9 + k); // 约束条件4 - 对应第244~324列 // 第243+id列表示第i行第j列填写有数字 dlx.Link(pid,243 + id); } void set_board() //把原数独矩阵转化成729*324的01矩阵 { int i,j,k; for(i = 1; i <= 9; i++){ for(j = 1; j <= 9; j++){ if(s[i][j] == ‘0‘){ //位置(i,j)值不确定，可以为1~9 for(k = 1; k <= 9; k++){ setmx(i,j,k); } } else{ //位置(i,j)值确定为k k = s[i][j] - ‘0‘; setmx(i,j,k); } } } } int ans[12][12]; //数独答案 void print() //精确覆盖答案还原成数独答案 { int i,j,k; for(int id=0;id<dlx.ansd;id++) { int a=dlx.ans[id]; //ans[]存的是精确覆盖行号 //行号 pid = (((i - 1) * 9 + j)-1)+k; //由此可以还原i,j,k的值 //即得到信息，第i行第j列位置值为k //注意i,j,k取值范围均为1~9 k=a%9; if(k==0) k=9; //得到k a-=k; a/=9; a+=1; j=a%9; if(j==0) j=9; //得到 j a-=j; a/=9; a+=1; i=a%9; if(i==0) i=9; //得到 i ans[i][j]=k; //方案 第 i 行第 j 列填写数字 k } //输出数独答案 for(i=1;i<=9;i++) for(j=1;j<=9;j++) { if(j!=9) cout<<ans[i][j]<<‘ ‘; else cout<<ans[i][j]<<endl; } } int main() { int T; int n,m; scanf("%d",&T); while(T--) { for(int i = 1; i <= 9; i++) for(int j = 1; j <= 9; j++) scanf(" %c",&s[i][j]); //输入原数独矩阵 //9*9的数独问题转化为729*324的01矩阵的精确覆盖 n = 729; //729个方案。对应01矩阵有729行。 m = 324; //324个约束条件，对应的01矩阵有324列 dlx.init(n,m); set_board(); //数独矩阵转化为729*324的01矩阵 dlx.exact_Dance(0); //DLX求解精确覆盖 print(); //输出数独答案 } return 0; }
hihoCoder #1321 : 搜索五?数独 （Dancing Links ,精确覆盖）
标签：
原文地址：http://www.cnblogs.com/smartweed/p/5879565.html
