POJ2676，HDU4069解决数独的两种实现：DFS、DLX

搜索实现：解决数独有两种思考策略，一种是枚举当前格能填的数字的种数，这里有一优化策略就是先搜索能填入种数小的格子；另一种是考虑处理某一行（列、宫）时，对于某一个没用过的数字，若该行（列、宫）只有一个可行的空白格时，就只能将该数字填入此格中。第二种实现起来略麻烦，此处仅实现第一种策略，并调整搜索顺序进行优化操作，优先搜索能填数字种数较小的格子。

另外，在搜索时，条件判断的效率尤为重要，故分别记录各行、各列、各宫已经出现的数字，这样就可以直接判断该空格填入某数字是否可行。

以POJ2676为例，无调整搜索顺序的优化，用时26ms，调整搜索顺序后用时0ms。

 //dfs搜索，枚举当前格能填的数字
 #include <stdio.h>
 #include <algorithm>
 using namespace std;
 const int N = ;
 char mp[N+][N+];
 int row[N+], col[N+], squ[N+];
 struct p{
     int x, y, z;
     p(int a = , int b = , int c = ) :x(a), y(b), z(c){}
     bool operator <(const p& m)const {
         return z < m.z;
     }
 };
 p pa[N*N+];
 int tot;

 bool dfs(int d) {
     if (d == tot) return true;

     for(int i = d; i < tot; i++){
         int nn = , x = pa[i].x, y = pa[i].y;
         pa[i].z = ;
         for(int j = ; j < ; j <<= )
             if( !(row[x]&j) && !(col[y]&j) && !(squ[x/*+y/]&j) )
                 pa[i].z++;
     }
     sort(pa+d, pa+tot);//调整搜素顺序！！

     int x = pa[d].x, y = pa[d].y;
     for(int i = ; i <= N; i++){
         int j =  <<(i-);
         if(!(row[x]&j) && !(col[y]&j) && !(squ[x/*+y/]&j)){
             row[x] ^= j, col[y] ^= j, squ[x/*+y/] ^= j;
             mp[x][y] = ''+i;
             if(dfs(d+)) return true;
             row[x] ^= j, col[y] ^= j, squ[x/*+y/] ^= j;
         }
     }
     return false;
 }

 int main(){
     int t; scanf("%d", &t);
     while(t--){
         for(int i = ; i < ; i++)
             for(int j = ; j < ; j++)
                 scanf(" %c", &mp[i][j]);

         for(int i = ; i < N; i++)
             row[i] = col[i] = squ[i] = ;
         tot = ;

         for(int i = ; i < N; i++)
             for(int j = ; j < N; j++)
                 if(mp[i][j] != ''){
                     int idx = mp[i][j]-'';
                     row[i] |= <<idx, col[j] |= <<idx, squ[i/*+j/] |= <<idx;
                 }
                 else
                     pa[tot++] = p(i, j);

         for(int i = ; i < tot; i++){
             int nn = , x = pa[i].x, y = pa[i].y;
             for(int j = ; j < ; j <<= )
                 if( !(row[x]&j) && !(col[y]&j) && !(squ[x/*+y/]&j) )
                     pa[i].z++;
         }

         dfs();

         for (int i = ; i < ; ++i)
             puts(mp[i]);
     }
     return ;
 }

DLX算法的POJ2676

 //******************************************************//
 //输入T表示T组数据。                                    //
 //每组数据为9个长度为9的字符串，空白处以字符0替代。        //
 //POJ2676                                               //
 //******************************************************//

 #include <bits/stdc++.h>
 using namespace std;
 const int maxnode = ;
 const int MaxM = ;
 const int MaxN = ;
 struct DLX{
     int n, m, size;                 //行数，列数，总数
     int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
     int H[MaxN], S[MaxM];           //S记录该列剩余1的个数，H表示该行最左端的1
     int ansd, ans[MaxN];

     void init(int _n, int _m){
         n = _n;
         m = _m;
         for(int i = ; i <= m; i++){
             S[i] = ;
             U[i] = D[i] = i;
             L[i] = i-;
             R[i] = i+;
         }
         R[m] = ; L[] = m;
         size = m;
         memset(H, -, sizeof(H));
     }
     void Link(int r, int c){
         size++;
         Col[size] = c, Row[size] = r;
         S[c]++;
         U[size] = U[c], D[size] = c;
         D[U[c]] = size;
         U[c] = size;
         if (H[r] != -) {
             R[size] = H[r] ;
             L[size] = L[H[r]] ;
             R[L[size]] = size ;
             L[R[size]] = size ;
         }
         else
             H[r] = L[size] = R[size] = size ;
     }
     void remove(int c){//覆盖第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[Col[j]];
             }
     }
     void 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[j]];
                 U[D[j]] = j;
                 D[U[j]] = j;
             }
         L[R[c]] = R[L[c]] = c;
     }
     //d为递归深度
     bool dance(int d){
         if(R[] == ){
             ansd = d;
             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[d] = Row[i];
             for(int j = R[i]; j != i; j = R[j]) remove(Col[j]);
             if(dance(d+)) return true;
             for(int j = L[i]; j != i; j = L[j]) resume(Col[j]);
         }
         resume(c);
         return false;
     }
 };
 DLX g;
 char s[][];
 int main(){
     int t;
     scanf("%d", &t);
     while(t--){
         for(int i = ; i < ; i++)
             scanf("%s", s[i]);

         g.init(*, +++);

         for(int i = ; i < ; i++)
             for(int j = ; j < ; j++){
                 int x = i, y = j, z = x/*+y/, w = i*+j;
                 if(s[i][j] == ''){
                     for(int k = ; k <= ; k++){
                         g.Link(w*+k, w+);
                         g.Link(w*+k, +x*+k);
                         g.Link(w*+k, +y*+k);
                         g.Link(w*+k, +z*+k);
                     }
                 }
                 else {
                     int t = s[i][j]-'';
                     g.Link(w*+t, w+);
                     g.Link(w*+t, +x*+t);
                     g.Link(w*+t, +y*+t);
                     g.Link(w*+t, +z*+t);
                 }
             }
         g.dance();

         for(int i = ; i < g.ansd; i++){
             int t = g.ans[i];
             int a = (t-)/, b = (t-)%+'';
             s[a/][a%] = b;
         }
         for(int i = ; i < ; i++)
             puts(s[i]);
     }
     return ;
 }

DLX算法很容易，套个框架就能解决了，还能高效解决变形数独。用HDU4069，一个变形数独为例。

 //******************************************************//
 //hdu4069                                               //
 //******************************************************//
 #include <bits/stdc++.h>
 using namespace std;
 const int MaxM = +;
 const int MaxN = +;
 const int maxnode = MaxM*MaxN;
 struct DLX{
     int n, m, size;                 //行数，列数，总数
     int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
     int H[MaxN], S[MaxM];           //S记录该列剩余1的个数，H表示该行最左端的1
     int ansd, ans[MaxN];
     int temp[MaxN];
     int tot;

     void init(int _n, int _m){
         n = _n;
         m = _m;
         for(int i = ; i <= m; i++){
             S[i] = ;
             U[i] = D[i] = i;
             L[i] = i-;
             R[i] = i+;
         }
         R[m] = ; L[] = m;
         size = m;
         memset(H, -, sizeof(H));

         tot = ;
     }
     void Link(int r, int c){
         size++;
         Col[size] = c, Row[size] = r;
         S[c]++;
         U[size] = U[c], D[size] = c;
         D[U[c]] = size;
         U[c] = size;
         if (H[r] != -) {
             R[size] = H[r] ;
             L[size] = L[H[r]] ;
             R[L[size]] = size ;
             L[R[size]] = size ;
         }
         else
             H[r] = L[size] = R[size] = size ;
     }
     void remove(int c){//覆盖第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[Col[j]];
             }
     }
     void 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[j]];
                 U[D[j]] = j;
                 D[U[j]] = j;
             }
         L[R[c]] = R[L[c]] = c;
     }
     //d为递归深度
     int dance(int d){
         if(R[] == ){
             ansd = d;
             for(int i = ; i < ansd; i++)
                 ans[i] = temp[i];
             tot++;
             return tot;
         }
         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]){
             temp[d] = Row[i];
             for(int j = R[i]; j != i; j = R[j]) remove(Col[j]);
             if(dance(d+) > ) return tot;
             for(int j = L[i]; j != i; j = L[j]) resume(Col[j]);
         }
         resume(c);
         return tot;
     }
 };
 DLX g;

 int a[][];
 int gird[][];
 int d[][] = {{-,},{,},{,},{,-}};//u,r,d,l
 void dfs(int x, int y, int color){
     gird[x][y] = color;
     for(int i = ; i < ; i++){
         int xx = x+d[i][], yy = y+d[i][];
         if((a[x][y] & (<<i))== &&xx >= && xx < &&yy >= &&yy <&&gird[xx][yy] == -)
             dfs(xx, yy, color);
     }
     return ;
 }

 int main(){
     int T; scanf("%d", &T);
     for(int ca = ; ca <= T; ca++){
         for(int i = ; i < ; i++)
             for(int j = ; j < ; j++)
                 scanf("%d", &a[i][j]);
         memset(gird, -, sizeof(gird));
         int tt = ;
         for(int i = ; i < ; i++)
             for(int j = ; j < ; j++)
                 if(gird[i][j] == -) dfs(i, j, tt++);

         g.init(*, *);
         for(int i = ; i < ; i++)
             for(int j = ; j < ; j++){
                 int t = (a[i][j]&), w = i*+j, x = i, y = j, z = gird[i][j];
                 if(t){
                     g.Link(w*+t, w+);
                     g.Link(w*+t, +x*+t);
                     g.Link(w*+t, +y*+t);
                     g.Link(w*+t, +z*+t);
                 }else {
                     for(int k = ; k <= ; k++){
                         g.Link(w*+k, w+);
                         g.Link(w*+k, +x*+k);
                         g.Link(w*+k, +y*+k);
                         g.Link(w*+k, +z*+k);
                     }
                 }
             }

         printf("Case %d:\n", ca);
         int ret = g.dance();
         if(ret == ){
             for(int i = ; i < g.ansd; i++){
                 int t = g.ans[i];
                 int x = (t-)/, y = (t-)%+;
                 a[x/][x%] = y;
             }
             for(int i = ; i < ; i++){
                 for(int j = ; j < ; j++)
                     printf("%d", a[i][j]);
                 puts("");
             }
         }
         else if(ret > ) puts("Multiple Solutions");
         else puts("No solution");
     }
     return ;
 }