[poj3074]Sudoku(舞蹈链)

题目链接：http://poj.org/problem?id=3074

舞蹈链精确覆盖的经典题目，一个数独每个位置的要求，可以得到以下四个约束
1.每个位置有且只有一个数字
2.每个位置的数字在一行只能出现一次
3.每个位置的数字在一列只能出现一次
4.每个位置的数字在一个宫格内只能出现一次
然后针对每个位置可以建立舞蹈链了
前81列，为1条件的约束
82-162列，为2条件的约束
163-243列，为3条件的约束
244-324列，为4条件的约束
则舞蹈链行数为确定的点数+未确定的点数*9，列数为324。
如果i行j列为数k，对应行则在(i - 1) 9 + j列，(i - 1) 9 + k + 81列， (j - 1) 9 + k + 162列，(((i - 1) / 3) 3 + ((j + 2) / 3) - 1)* 9 + k + 243列建立。
如果i行j列为未知数,则k为1-9，对于每个k都应该建立行列关系。

 #include<iostream>
 #include<cstdio>
 #include<vector>
 #include<cstring>
 #include<string>
 #include<algorithm>
 #include<set>
 #include<cstdlib>
 #include<map>
 #include<queue>
 #include<cmath>
 using namespace std;
 typedef long long ll;
 const int MN = ;
 const int MM = ;
 const int MNN = MN * MM + ;
 struct DLX {

     int n, m, size;//一共n行m列，size个节点
     int U[MNN], D[MNN], L[MNN], R[MNN], row[MNN], col[MNN];//第i个节点的上U下D左L右R，所在位置row行col列
     int H[MNN], S[MM];//H数组记录行选择指针，S数组记录覆盖个数
     int ansd, ans[MN];//res记录行个数，ans数组记录可行解
     void init(int x, int y) {//初始化空表
         n = x, m = y;
         for (int i = ; i <= m; ++i) {//其中0节点作为head节点,其他作为列首节点
             U[i] = D[i] = i;
             L[i] = i - ;
             R[i] = i + ;
         }
         R[m] = ; L[] = m;
         size = m;
         memset(S, , sizeof(S));
         memset(H, -, sizeof(H));
     }
     void Link(int r, int c) {
         size++; row[size] = r; col[size] = c; S[c]++;//节点数加一，设置s节点所处位置，以及S列覆盖个数加一
         D[size] = D[c]; U[D[c]] = size;//将s节点插入对应列中
         U[size] = c; D[c] = size;
         if (H[r] < )//如果该行没有元素，H[r]标记该行起始节点
             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 remove(int c) {//删除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数组减一
                 --S[col[j]];
             }
         }
     }
     void resume(int c) {//恢复c列
         for (int i = U[c]; i != c; i = U[i]) {//枚举该列元素
             for (int j = L[i]; j != i; j = L[j]) {
                 U[D[j]] = j; D[U[j]] = j;
                 ++S[col[j]];
             }
         }
         L[R[c]] = c; R[L[c]] = c;
     }
     bool dancing(int deep) {
         if (R[] == ) {//当矩阵为空时,说明找到一个可行解，算法终止
             ansd = deep;
             return true;
         }
         int c = R[];//找到节点数最少的列，枚举这列上的所有行
         for (int i = R[]; i != ; i = R[i]) {
             if (S[i] < S[c]) {
                 c = i;
             }
         }
         remove(c);//删除节点数最少的列
         for (int i = D[c]; i != c; i = D[i]) {
             ans[deep] = row[i];//将行r放入当前解
             for (int j = R[i]; j != i; j = R[j])//行上节点对应的列上进行删除
                 remove(col[j]);
             //进入下一层
             if (dancing(deep + ))return true;
             //对行上的节点对应的列进行恢复
             for (int j = L[i]; j != i; j = L[j])
                 resume(col[j]);
         }
         //恢复节点数最少列
         resume(c);
         return false;
     }
 };
 DLX dzl;
 int mp[][];
 int x[];
 int y[];
 int kk[];
 int main() {
     char s[];
     while (cin >> s) {
         if (strcmp(s, "end") == )
             break;
         for (int i = ; i < ; i++) {
             int xx = i / ;
             int yy = i % ;
             if (s[i] == '.')
                 mp[xx + ][yy + ] = ;
             else
                 mp[xx + ][yy + ] = s[i] - '';
         }
         dzl.init(, );
         int len = ;
         for (int i = ; i <= ; i++) {
             for (int j = ; j <= ; j++) {
                 if (mp[i][j] == ) {
                     for (int k = ; k <= ; k++) {
                         dzl.Link(len, (i - ) *  + j);
                         dzl.Link(len, (i - ) *  + k + );
                         dzl.Link(len, (j - ) *  + k + );
                         dzl.Link(len, (((i - ) / ) *  + ((j + ) / ) - ) *  + k + );
                         x[len] = i, y[len] = j, kk[len] = k;
                         len++;
                     }
                 }
                 else {
                     int k = mp[i][j];
                     dzl.Link(len, (i - ) *  + j);
                     dzl.Link(len, (i - ) *  + k + );
                     dzl.Link(len, (j - ) *  + k + );
                     dzl.Link(len, (((i - ) / ) *  + ((j + ) / ) - ) *  + k + );
                     x[len] = i, y[len] = j, kk[len] = k;
                     len++;
                 }
             }
         }
         dzl.dancing();
         for (int i = ; i < dzl.ansd; i++) {
             int r = dzl.ans[i];
             mp[x[r]][y[r]] = kk[r];
         }
         for (int i = ; i <= ; i++) {
             for (int j = ; j <= ; j++) {
                 printf("%d", mp[i][j]);
             }
         }
         puts("");
     }
 }