UVa 1309 DLX Sudoku

16×16的数独。

看白书学的DLX，有些细节还有待消化，贴个模板先。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <queue>
 using namespace std;

 const int maxn = ;
 const int maxnode =  + ;
 const int maxr =  + ;
 const int maxc =  + ;

 #define FOR(i,A,s) for(int i = A[s]; i != s; i = A[i])

 struct DLX
 {
     int n, sz;
     int S[maxc];

     int row[maxnode], col[maxnode];
     int L[maxnode], R[maxnode], U[maxnode], D[maxnode];

     int ansd, ans[maxr];

     void init(int n)
     {
         this-> n = n;

         for(int i = ; i <= n; i++) {
             U[i] = D[i] = i; L[i] = i - ; R[i] = i + ;
         }
         L[] = n; R[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 - ;
     }

     void remove(int c)
     {
         L[R[c]] = L[c];
         R[L[c]] = R[c];
         FOR(i,D,c)
             FOR(j,R,i) { U[D[j]] = U[j]; D[U[j]] = D[j]; --S[col[j]]; }
     }

     void restore(int c)
     {
         FOR(i,U,c)
             FOR(j,L,i) { ++S[col[j]]; U[D[j]] = j; D[U[j]] = j; }
         L[R[c]] = c;
         R[L[c]] = c;
     }

     bool dfs(int d)
     {
         if(R[] == ) { ansd = d; return true; }

         int c = R[];
         FOR(i,R,) if(S[i] < S[c]) c = i;

         remove(c);
         FOR(i,D,c)
         {
             ans[d] = row[i];
             FOR(j,R,i) remove(col[j]);
             if(dfs(d + )) return true;
             FOR(j,L,i) 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;
     }
 }solver;

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

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

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

 char G[maxn][maxn + ];

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

 int main()
 {
     int kase = ;
     while(read())
     {
         if(kase++ > ) puts("");

         solver.init();
         for(int r = ; r < ; r++)
             for(int c = ; c < ; c++)
                 for(int v = ; v < ; v++)
                     if(G[r][c] == '-' || G[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;
         solver.solve(ans);

         for(int i = ; i < ans.size(); i++) {
             int r, c, v;
             decode(ans[i], r, c, v);
             G[r][c] = 'A' + v;
         }

         for(int i = ; i < ; i++) printf("%s\n", G[i]);
     }

     return ;
 }

代码君