【dfs预处理+DLX】hdu 4069 Squiggly Sudoku

Source :hdu 4069 Squiggly Sudoku

http://acm.hdu.edu.cn/showproblem.php?pid=4069

Problem Description
Today we play a squiggly sudoku, The objective is to fill a 9*9 grid with digits so that each column, each row, and each of the nine Connecting-sub-grids that compose the grid contains all of the digits from 1 to 9.
Left figure is the puzzle and right figure is one solution.
Now, give you the information of the puzzle, please tell me is there no solution or multiple solution or one solution.

Input
The first line is a number T(1<=T<=2500), represents the number of case. The next T blocks follow each indicates a case.
Each case contains nine lines, Each line contains nine integers.
Each module number tells the information of the gird and is the sum of up to five integers:
0~9: ‘0’ means this gird is empty, ‘1’ - ‘9’ means the gird is already filled in.
16: wall to the up
32: wall to the right
64: wall to the down
128: wall to the left
I promise there must be nine Connecting-sub-grids, and each contains nine girds.

Output
For each case, if there are Multiple Solutions or no solution just output “Multiple Solutions” or “No solution”. Else output the exclusive solution.(as shown in the sample output)

题意

9X9的数独游戏，满足每行、每列、每宫填满1-9，注意“宫”的形状变化了！

示例

Sample Input
3
144 18 112 208 80 25 54 144 48
135 38 147 80 121 128 97 130 32
137 32 160 144 114 167 208 0 32
192 100 160 160 208 96 183 192 101
209 80 39 192 86 48 136 80 114
152 48 226 144 112 160 160 149 48
128 0 112 166 215 96 160 128 41
128 39 153 32 209 80 101 136 35
192 96 200 67 80 112 208 68 96

144 48 144 81 81 16 53 144 48
128 96 224 144 48 128 103 128 38
163 208 80 0 37 224 209 0 32
135 48 176 192 64 112 176 192 104
192 101 128 89 80 82 32 150 48
149 48 224 208 16 48 224 192 33
128 0 114 176 135 0 80 112 169
137 32 148 32 192 96 176 144 32
192 96 193 64 80 80 96 192 96

144 88 48 217 16 16 80 112 176
224 176 129 48 128 40 208 16 37
145 32 128 96 196 96 176 136 32
192 32 227 176 144 80 96 192 32
176 192 80 98 160 145 80 48 224
128 48 144 80 96 224 183 128 48
128 36 224 144 51 144 32 128 105
131 64 112 136 32 192 36 224 176
224 208 80 64 64 116 192 83 96

Sample Output

Case 1:
521439678
763895124
984527361
346182795
157964832
812743956
235678419
479216583
698351247
Case 2:
No solution
Case 3:
Multiple Solutions

---

思路

dfs预处理给所有的小格确定所属的方阵编号，然后DLX精确覆盖即可，这题收获很大，有以下三点：

1.dlx转换为精确覆盖问题时，列任务有4个，分别构成N×N×4列，其中sub(a,b)表示第a个子方阵要有字母b，普通的数独游戏根据元素(r,c)在第r行第c列就可以确定属于哪个a方阵，这道题特殊就特殊在方阵形状变了，你需要重新给(r,c)所属方阵编号了，怎么做?dfs所有点，利用位运算判断是否越界，预处理得到所有方格(i,j)所属方阵编号block[ i ][ j ];再构造724×324矩阵时把sub(a,b)替换为block[ r ][ c ]就ok了！

2.难点！做着做着你会发现，解的个数与最终的解不可兼得，因为回溯!所以中间的答案没有得到保留。怎么破？！当解的个数为1时，把答案ans存起来，最终要是解的个数就是1，直接输出刚才保存的结果，否则就是多解，我们也不用把所有的结果都存起来了。

3.成也剪枝！结果没问题，但最终还是TLEＱＡＱ，什么情况？处理解的个数，当为２时就return好了，不用继续dlx了,做题和解决问题还是有点区别啊Orz..

补充：如果遇到要求出所有的解，每到递归基就打印一次，没必要存储所有结果了！模板dlx输出的是第一组可行解，至于有没有其他的不知道，把dfs里面的return去掉就可以了。

---

参考代码

/*====================================*\
|*     舞蹈链    DLX                  *|
\*====================================*/
/*Author:Hacker_vision*/
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<vector>
#include<map>
#include<climits>
#define clr(k,v) memset(k,v,sizeof(k))
#define ll long long
#define eps 1e-8
using namespace  std;

const int SLOT = 0;
const int ROW = 1;
const int COL = 2;
const int SUB = 3;
const int N = 9;
const int M = 3;
const int maxr = N*N*N + 10;//行数
const int maxn = N*N*4 + 10;//列数
const int maxnode = maxr*maxn + 10;//总节点数
int tot,g[12][12];
int top,temp[maxr];

struct DLX{
  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 = 0; i <= n; ++ i){
     U[i] = i;D[i] = i;L[i] = i - 1;R[i] = i + 1;
   }
   R[n] = 0;L[0] = n;
   sz = n + 1;
   memset(S,0,sizeof(S));
  }
  void addRow(int r,vector<int>columns){
   int first= sz;
   for(int i = 0; i < columns.size(); ++ i){
    int c = columns[i];
    L[sz] = sz - 1;R[sz] = sz + 1;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 - 1] = first;L[first] = sz - 1;
  }
  //顺着链表A,遍历除s外的其他元素
 // #define FOR(i,A,s) for(int i = A[s]; i != s;i = A[i])
  void remove(int 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 restore(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]] = c;
      R[L[c]] = c;
  }
  bool dfs(int d){
    if(R[0] == 0){
        ansd = d;//选了ansd行
        tot++;
        if(tot == 1){
            top = ansd;//ansd是局部变量，拿出来
            for(int i = 0; i < ansd; ++ i) temp[i] = ans[i];
        }
        return true;
    }
    //找S的最小列
    int c = R[0]; //第一个未删除的列
    for(int i = R[0];i != 0; 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]);
        dfs(d+1);
        if(tot > 1) return true;
        for(int j = L[i]; j != i; j = L[j]) restore(col[j]);
    }
    restore(c);
    return false;
  }
  bool solve(vector<int>&v){//solve函数这里就没用了，因为回溯！
    v.clear();
    if(!dfs(0)) return false;
    for(int i = 0; i < ansd; ++ i) v.push_back(ans[i]);
    return true;
  }
};

//行、列的统一编解码函数。从1开始编号
int encode(int a,int b,int c){
  return a*N*N + b*N + c + 1;
}

void decode(int code,int& a,int& b,int& c){
  code--;
  c = code%N; code/=N;
  b = code%N; code/=N;
  a = code;
}
//block[][]也可以当做vis[][]用，比较巧妙
int block[12][12],dir[4][2]={-1,0,0,1,1,0,0,-1};//四个方向,16,32,64,128决定的方向
void dfs(int x,int y){//函数重载，哈哈!
  block[x][y] = tot;
  for(int i = 0; i < 4; ++ i){
    int xx = x + dir[i][0];
    int yy = y + dir[i][1];
    if(xx>=0&&yy>=0&&xx<N&&yy<N&&block[xx][yy]==-1&&(g[x][y]&(1<<(i+4)))==0){
       dfs(xx,yy);                                  //g[x][y]&(1<<(1+4)) == 0，说明g[x][y]没有32，可以往右走，dir方向很重要
    }
  }
}

DLX dlx;

int main(){
  #ifndef ONLINE_JUDGE
  freopen("input.txt","r",stdin);
  #endif // ONLINE_JUDGE
  int T;cin>>T;int cnt=1;
  while(T--){
    for(int i = 0; i < N; ++ i)
        for(int j = 0;j < N; ++ j)
        scanf("%d",&g[i][j]);
    //预处理，得到block[r][c],确定(r,c)所在方阵编号0-8
    clr(block,-1);
    tot = 0;//初始化方阵编号
    for(int i = 0; i < N; ++ i)//遍历所有点确定所有点的编号，最好情况下有效循环次数9次
     for(int j = 0; j < N; ++ j)
     if(block[i][j] == -1){
      dfs(i,j);
      tot++;
     }
    //跑DLX即可，注意列任务的第4个传参的含义
    dlx.init(N*N*4);//列数
    for(int r = 0; r < N; ++ r)
      for(int c = 0; c < N; ++ c)
        for(int v = 0; v < N; ++ v){
          int k = g[r][c]&15;//取低四位!!!!!
          if(k == 0||k == 1 + v){
          vector<int>columns;
          columns.push_back(encode(SLOT,r,c));//列数分四种情况,r行c列要有数字
          columns.push_back(encode(ROW,r,v));//r行要有数字v
          columns.push_back(encode(COL,c,v));//c列要有数字v
          columns.push_back(encode(SUB,block[r][c],v));//第x个方阵要有数字v,之前根据(r,c)大小直接确定第几个方阵，现在需要预处理一下,block[r][c]返回(r,c)所属方阵编号
          dlx.addRow(encode(r,c,v),columns);//上一步传参，方阵编号(0~8)
          }
        }
   tot = 0;
   dlx.dfs(0);
   //控制输出
   printf("Case %d:\n",cnt++);
  // printf("解得个数tot = %d\n",tot);
   if(!tot) puts("No solution");
   else if(tot > 1) puts("Multiple Solutions");
   else{
    for(int i = 0; i < top; ++ i){
        int r,c,v;
        decode(temp[i],r,c,v);
        g[r][c] = 1 + v;
    }
    for(int i = 0; i < N; ++ i){
        for(int j = 0; j < N; ++ j)
            printf("%d",g[i][j]);
        puts("");
    }
   }
  }
  return 0;
}

• 加粗 Ctrl + B
• 斜体 Ctrl + I
• 引用 Ctrl + Q
• 插入链接 Ctrl + L
• 插入代码 Ctrl + K
• 插入图片 Ctrl + G
• 提升标题 Ctrl + H
• 有序列表 Ctrl + O
• 无序列表 Ctrl + U
• 横线 Ctrl + R
• 撤销 Ctrl + Z
• 重做 Ctrl + Y