UVALive 2659 数独 DLX模板

建图：

　　从1到16枚举所有的行、列上放的数。

代码：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <cmath>
 #include <algorithm>
 #include <string>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <functional>
 #include <cctype>
 #include <time.h>

 using namespace std;

 const int INF = <<;
 const int MAXN = ;
 const int MAXNODE = ;
 const int MAXR = ;

 struct DLX {
 // 行编号从1开始，列编号为1~n，结点0是表头结点；结点1~n是各列顶部的虚拟结点
     int n, sz; // 列数，结点总数
     int S[MAXN]; //各列结点数

     int row[MAXNODE], col[MAXNODE]; //各结点行列编号
     int L[MAXNODE], R[MAXNODE], U[MAXNODE], D[MAXNODE]; //十字链表

     int ansd, ans[MAXR]; // 解

     void init(int n)  { //n是列数
         this->n = n;

         //虚拟结点
         for (int i = ; i <= n; i++) {
             U[i] = i; D[i] = i; L[i] = i-; R[i] = i+;
         }
         R[n] = ; L[] = n;
         sz = n+;
         memset(S, , sizeof(S));
     }

     void addRow(int r, vector<int> columns) {
         //这一行的第一个结点
         //行没有设头结点，每一行连成一个环形
         int first = sz;
         for (int i = ; i < columns.size(); i++) {
             int c = columns[i];
             L[sz] = sz-; R[sz] = sz+; D[sz] = c; U[sz] = U[c];
             D[U[c]] = sz; U[c] = sz;
             row[sz] = r; col[sz] = c;
             S[c]++; sz++;
         }
         R[sz-] = first; L[first] = sz-;
     }

     //顺着链表A，遍历s外的其他元素
     #define FOR(i, A, s) for (int i = A[s]; i != s; i = A[i])

     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]) // 对于每一个c列不为0的所有行
             for (int j = R[i]; j != i; j = R[j]) { //删除这一整行
                 U[D[j]] = U[j]; D[U[j]] = D[j]; S[col[j]]--;
             }
     }

     void restore(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 dfs(int d) { //d为递归深度
         if (R[] == ) { //找到解
             ansd = d; //记录解的长度
             return true;
         }

         //找S最小的C列
         int c = R[]; //第一个未删除的列
         for (int i = R[]; i != ; i = R[i]) if (S[i]<S[c]) c = i;

         remove(c); //删除第c列
         for (int i = D[c]; i != c; i = D[i]) { //用结点i所在的行覆盖第c列
             ans[d] = row[i];
             for (int j = R[i]; j != i; j = R[j]) remove(col[j]); //删除节结点i所在行覆盖第c列
             if (dfs(d+)) return true;
             for (int j = L[i]; j != i; j = L[j]) restore(col[j]); // 恢复
         }
         restore(c); //恢复
         return false;
     }

     bool solve(vector<int> &v) {
         v.clear();
         if(!dfs()) return false;
         for (int i = ; i < ansd; i++) v.push_back(ans[i]);
         return true;
     }
 };

 const int SLOT = ;
 const int ROW = ;
 const int COL = ;
 const int SUB = ;

 inline int encode(int a, int b, int c) {
     return a* + b* + c + ;
 }

 inline void decode(int code, int &a, int &b, int &c) {
     code--;
     c = code%; code /= ;
     b = code%; code /= ;
     a = code;
 }

 char puzzle[][];

 bool read() {
     for (int i = ; i < ; i++)
         if (scanf("%s", puzzle[i])!=) return false;
     return true;
 }

 DLX solver;

 int main() {
     #ifdef Phantom01
         freopen("LA2659.txt", "r", stdin);
     #endif //Phantom01

     int T= ;

     while (read()) {
         if (T!=) puts(""); T++;
         solver.init();
         for (int r = ; r < ; r++)
             for (int c = ; c < ; c++)
                 for (int v = ; v < ; v++)
                     if (puzzle[r][c]=='-'|| puzzle[r][c]=='A'+v) {
                         vector<int> columns;
                         columns.push_back(encode(SLOT, r, c));
                         columns.push_back(encode(ROW, r, v));
                         columns.push_back(encode(COL, c, v));
                         columns.push_back(encode(SUB, (r/)*+c/, v));
                         solver.addRow(encode(r, c, v), columns);
                     }
         vector<int> ans;
         if (!solver.solve(ans)) while () ;

         for (int i = ; i < ans.size(); i++) {
             int r, c, v;
             decode(ans[i], r, c, v);
             puzzle[r][c] = 'A'+v;
         }
         for (int i = ; i < ; i++) {
             printf("%s\n", puzzle[i]);
         }
     }

     return ;
 }