poj 3074

题意：解数独

分析：

完整的数独有四个充要条件：

1.每个格子都有填数字

2.每列都有1~9中的每个数字

3.每行都有1~9中的每个数字

4.每个9宫格都有1~9中的每个数字

可以转化成精确覆盖问题。每行表示一个格子的一种填法，1~81列表示这个格子的位置，82~162列表示这是哪一行的什么数字，163~243列表示这是哪一列的什么数字，244~324列表示这是哪一个九宫格里的什么数字。每行都把四个1填入这四个区间里的对应位置。最后求出这个01矩阵的精确覆盖就是解。

在DFS里删除列的顺序为由左往右时TLE了，由右向左却AC，什么原因？？？

 #include <cstdio>
 #include <cstring>
 int U[],D[],L[],R[],row[],col[],cont[];
 int X[],Y[],H[],S[],M,N,sz,ans[][];
 bool hashr[][],hashc[][],hashp[][];
 void init(int m)
 {
     for(int i = ;i <= m;i++)
     {
         U[i] = D[i] = i;
         L[i + ] = i;
         R[i] = i + ;
         S[i] = ;
     }
     R[m] = ;
     L[] = m;
     sz = m + ;
 }

 void remove(int c)
 {
     //删除一整列
     R[L[c]] = R[c];
     L[R[c]] = L[c];
     //删除行
     for(int i = D[c];i != c;i = D[i])
     {
         for(int j = R[i];j != i;j = R[j])
         {
             D[U[j]] = D[j];
             U[D[j]] = U[j];
             S[X[j]]--;
         }
     }
 }

 void resume(int c)
 {
     //恢复一整列
     L[R[c]] = c;
     R[L[c]] = c;
     //恢复行
     for(int i = U[c];i != c;i = U[i])
     {
         for(int j = L[i];j != i;j = L[j])
         {
             D[U[j]] = j;
             U[D[j]] = j;
             S[X[j]]++;
         }
     }
 }

 void ins(int r,int c)
 {
     S[c]++;
     //纵向插入
     D[U[c]] = sz;
     U[sz] = U[c];
     D[sz] = c;
     U[c] = sz;
     X[sz] = c;
     Y[sz] = r;
     //横向插入
     if(H[r] == -)
     {
         H[r] = L[sz] = R[sz] = sz;
     }
     else
     {
         R[L[H[r]]] = sz;
         L[sz] = L[H[r]];
         R[sz] = H[r];
         L[H[r]] = sz;
     }
     sz++;
 }

 bool dfs(int k)
 {
     if(R[] == )
     {
         return true;
     }
     else
     {
         int m = 0xfffffff,num;
         for(int i = R[];i != ;i = R[i])
         {
             if(S[i] == )
             {
                 return false;
             }
             if(m > S[i])
             {
                 m = S[i];
                 num = i;
                 if(m == )
                 {
                     break;
                 }
             }
         }
         remove(num);
         for(int i = D[num];i != num;i = D[i])
         {
             ans[row[Y[i]]][col[Y[i]]] = cont[Y[i]];
             for(int j = R[i];j != i;j = R[j])
             {
                 remove(X[j]);
             }
             if(dfs(k + ))
             {
                 return true;
             }
             for(int j = L[i];j != i;j = L[j])//恢复顺序改为由左向右居然慢N倍？！
             {
                 resume(X[j]);
             }
         }
         resume(num);
     }
     return false;
 }

 int main()
 {
     char input[];
     while(scanf("%s",input),input[] != 'e')
     {
         memset(hashr,false,sizeof(hashr));
         memset(hashc,false,sizeof(hashc));
         memset(hashp,false,sizeof(hashp));
         for(int i = ;i < ;i++)
         {
             for(int j = ;j < ;j++)
             {
                 if(input[i *  + j] != '.')
                 {
                     hashr[i][input[i *  + j] - ''] = true;
                     hashc[j][input[i *  + j] - ''] = true;
                     hashp[i /  *  + j / ][input[i *  + j] - ''] = true;
                 }
             }
         }
         M =  *  * ;
         N = ;
         init(M);
         for(int i = ;i < ;i++)
         {
             for(int j = ;j < ;j++)
             {
                 int k;
                 if(input[i *  + j] != '.')
                 {
                     k = input[i *  + j] - '';
                 }
                 else
                 {
                     k = ;
                 }
                 if(k != )
                 {
                     row[N] = i;
                     col[N] = j;
                     cont[N] = k;
                     H[N] = -;
                     ins(N,i *  + j + );//(i,j)位置已填数字
                     ins(N, + i *  + k);//i行已有k
                     ins(N, + j *  + k);//j列已有k
                     ins(N++, + (i /  *  + j / ) *  + k);//宫格已有k
                 }
                 else
                 {
                     for(k = ;k <= ;k++)
                     {
                         if(!hashr[i][k] && !hashc[j][k] && !hashp[i /  *  + j / ][k])
                         {
                             row[N] = i;
                             col[N] = j;
                             cont[N] = k;
                             H[N] = -;
                             ins(N,i *  + j + );//(i,j)位置已填数字
                             ins(N, + i *  + k);//i行已有k
                             ins(N, + j *  + k);//j列已有k
                             ins(N++, + (i /  *  + j / ) *  + k);//宫格已有k
                         }
                     }
                 }
             }
         }
         dfs();
         for(int i = ;i < ;i++)
         {
             for(int j = ;j < ;j++)
             {
                 printf("%d",ans[i][j]);
             }
         }
         printf("\n");
     }
     return ;
 }