PKU2676_数独

 

 

数独定义：一个九乘九矩阵，矩阵每一行的九个数为1 - 9 且不重复，每一列依然；而且，把九乘九矩阵从上到下，从左到右分为九个三乘三矩阵，每个小矩阵中的数字为1-9 且不重复

 

问题定义：以一个9 * 9 矩阵的形式输入一个不完整的数独，要求把矩阵中为 0 的位置填上 1 - 9 使构成一个数独，输出该结果。(结果可能多个，输出任意一个结果即可)

 

解决方案：普通深搜 ，递归实现

方案描述：定义矩阵第 row 行 ，第 column 列代表矩阵第 row * 9 + column 个位置

1. position = 0
2. 从第position 个位置开始搜索
3. 如果 position = 81 ，代表搜索已经结束，保存结果，end
4. begin
5.      if 第 position 个位置处的数字不为 0
6.            begin
7.                  从第 position + 1 个位置开始搜索
8.            end
9.      else
10.            对数字 i 取遍 1 - 9
11.                   begin
12.                          if 第 position 个位置可以放 i
13.                                 将第 position 个位置的数字设为 i
14.                                 递归地从第position + 1 个位置开始搜索
15.                                 将第 position 个位置的数字重新设回 0
16.                          end
17.                   end
18.      end
19. end
20.                         
21.        

剪枝策略：搜到一个还没有填数的位置，且填任何数都不对的时候，说明不是一个正确的数独，不再继续搜索，而是返回。

 

复杂度：不知道怎么算，请游客指教。

 

                              

代码：

版本1 ：Time Limit Exceeded #include<iostream> using namespace std; bool fstwayfound; char sudoku[9][10]; char ans[9][10]; void read() { for(int i = 0 ; i < 9 ; i ++) { cin.getline(sudoku[i] , 10); } } bool check(int row , int column , char c) { int i ; for(i = 0 ; i < 9 ; i ++) { if(sudoku[row][i] == c || sudoku[i][column] == c) return false; } int row_idx ,column_idx; for(row_idx = (row/3) * 3 ; row_idx < (row/3 + 1) * 3; row_idx ++) { for(column_idx = (column/3) * 3 ; column_idx < (column/3 + 1) * 3; column_idx ++) { if(sudoku[row_idx][column_idx] == c) return false; } } return true; } // 如果要搜索所有路径，可以去掉如下几部分代码： //if(fstwayfound)// 已经搜到第一条路，不必再搜了 //{ // return 0; //} //fstwayfound = true; //删除如上代码之后，solve 返回值代表从第position 个位置开始搜索能够得到的路径总数 int solve(int position) { int cnt = 0; if(fstwayfound)// 已经搜到第一条路，不必再搜了 { return 0; } if(position == 81) // 搜到最后一格 ，不必再搜索了 { fstwayfound = true; memcpy(ans , sudoku ,sizeof(ans)); return 1; } int row = position / 9; int column = position % 9; if(sudoku[row][column] != '0') { cnt += solve(position + 1); } else { for(char c = '1' ; c <= '9'; c++) { if(check(row , column , c )) { sudoku[row][column] = c; cnt += solve(position + 1); sudoku[row][column] = '0'; } } } return cnt; } void print() { for(int i = 0 ; i < 9 ; i ++) { printf("%s/n" ,ans[i]); } } int main() { int N; cin>>N; cin.get(); int i ; for(i = 1;i <= N; i++) { fstwayfound = false; read(); solve(0); print(); } return 1; }

 

 

这个题有点怪，据讨论，从后搜可以过，从前搜就TLE，因此修改代码如下，确实可以过，时间 16 MS , 内存216K

 

//版本二:版本一的简单修改；AC ，216K , 16MS ; //版本一、二是半斤八两都不合格，版本二不过是因为测试数据不好的原因侥幸得过 #include<iostream> using namespace std; bool fstwayfound; char sudoku[9][10]; char ans[9][10]; void read() { for(int i = 0 ; i < 9 ; i ++) { cin.getline(sudoku[i] , 10); } } bool check(int row , int column , char c) { int i ; for(i = 0 ; i < 9 ; i ++) { if(sudoku[row][i] == c || sudoku[i][column] == c) return false; } int row_idx ,column_idx; for(row_idx = (row/3) * 3 ; row_idx < (row/3 + 1) * 3; row_idx ++) { for(column_idx = (column/3) * 3 ; column_idx < (column/3 + 1) * 3; column_idx ++) { if(sudoku[row_idx][column_idx] == c) return false; } } return true; } // 如果要搜索所有路径，可以去掉如下几部分代码： //if(fstwayfound)// 已经搜到第一条路，不必再搜了 //{ // return 0; //} //fstwayfound = true; //删除如上代码之后，solve 返回值代表从第position 个位置开始搜索能够得到的路径总数 int solve(int position) { int cnt = 0; if(fstwayfound)// 已经搜到第一条路，不必再搜了 { return 0; } if(position == -1) // 搜到最后一格 ，不必再搜索了 { fstwayfound = true; memcpy(ans , sudoku ,sizeof(ans)); return 1; } int row = position / 9; int column = position % 9; if(sudoku[row][column] != '0') { cnt += solve(position - 1); } else { for(char c = '1' ; c <= '9'; c++) { if(check(row , column , c )) { sudoku[row][column] = c; cnt += solve(position - 1); sudoku[row][column] = '0'; } } } return cnt; } void print() { for(int i = 0 ; i < 9 ; i ++) { printf("%s/n" ,ans[i]); } } int main() { int N; cin>>N; cin.get(); int i ; for(i = 1;i <= N; i++) { fstwayfound = false; read(); solve(80); print(); } return 1; }

 

// 版本三：智能搜索; AC 228K 47MS ; code length 3899B // 搜索策略：优先对能够放最少的数字的空格进行填数，以期更早地剪枝 // 备注：为何能更早地剪枝，只是我的一种猜测 // 觉得如果局部的数字越密集，则导致整体的选择范围越小 #include<iostream> using namespace std; char sudoku[9][10];//用于保存输入的数独 char ans[9][10];//用于存放搜索到的完整数独 int cnt[9][9];//cnt[i][j] 用于记录sudoku[i][j] 处能够放置的数字的总数（粗略估计值） bool checked[9][9];//checked[i] 表示位置sudoku[i][j]位置处的所有可行方案都已经被检查过了 bool fstwayfound;// 用于指明已经发现了第一条道路 //输入不完整的数独，并进行一系列初始化 void read_init() { int i , j ,row , column; for(i = 0 ; i < 9 ; i++) { scanf("%s" , sudoku[i]); } memcpy(ans , sudoku , sizeof(ans)); for(row = 0 ; row < 9 ; row++) { for(column = 0 ; column < 9 ; column++) { // sudoku cnt[row][column] = 9; checked[row][column] = false; } } for(row = 0 ; row < 9 ; row++) { for(column = 0; column < 9 ; column++) { //如果已经填了数，就不必对该位置进行检查了 //因此 checked[row][column] 直接设为true //并且其它位置可以填的数的个数减少 if(sudoku[row][column] != '0') { checked[row][column] = true; for(i = 0 ; i < 9 ; i++) { cnt[row][i]--; cnt[i][column]--; } for(i = (row/3) * 3; i < (row/3 + 1) * 3 ; i++) { for(j = (column/3) * 3 ; j < (column/3 + 1) * 3 ; j++) { cnt[i][j]--; } } } } } } //从所有满足checked[row][column] == false 的位置中找出 cnt[row][column] 最小的位置 void getnxt(int & row , int & column) { //min 存放最小的 cnt 值 int i , j , min = 10; row = -1; column = -1; for(i = 0 ; i < 9 ; i++) { for(j = 0 ; j < 9 ; j++) { // min 初始化为 10 ，目的是防备cnt 数组中都为 9 的情况（也就是一个空数独） if(!checked[i][j] && cnt[i][j] < min) { row = i; column = j; min = cnt[i][j]; } } } } //前提：sudoku[row][column] != '0' && checked[row][column] == false bool valid(int row , int column , char char_to_fill) { int i , j; for(i = 0 ; i < 9 ; i++) { if(sudoku[row][i] == char_to_fill || sudoku[i][column] == char_to_fill) return false; } for(i = (row/3)*3 ; i < (row/3 + 1)*3 ; i++) { for(j = (column/3)*3 ; j < (column/3 + 1)*3; j++) { if(sudoku[i][j] == char_to_fill) return false; } } return true; } //如果删除如下代码，则solve返回从当前状态(指checked 和 sudoku 两个数组的状态) 下搜索能够得到的数独的个数 // if(fstwayfound) // solve 函数中 // return 0; // fstwayfound = true; // solve 函数中 // fstwayfound = false;// main 函数中 //如果不删除，则solve返回值无意义 //！！前提：必须保证刚开始输入的数独中所有sudoku[i][j] != '0'的位置都满足 checked[i][j] = true; //！！ 因而需要在read_init() 中对checked数组做相关处理 int solve() { // roadcnt 用于统计当前从位置(row ,column)出发可以找到的所有有效路径的总数 int roadcnt = 0; int i ,j; // 用于指出下一个要搜索的位置 int row ,column ; //从还没有搜过的位置中以某种策略找到下一个要搜索的位置 //！！注意：所有 getnxt(row , column); // 已经找到第一条路了 if(fstwayfound) return 0; // 如果所有的点都已经搜过了，说明已经搜到了一条完整路径 if(row == -1) { //已经找到了第一条路 fstwayfound = true; //ans数组存储答案 memcpy(ans , sudoku , sizeof(ans)); //返回 1 代表找到一条路 return 1; } //如果没有搜到尽头，则对位置sudoku[row][column]尝试所有可能字符( 1 --- 9) for(char c = '1'; c <= '9'; c++) { //调用valid 时参数 row column 要满足 checked[row][column] == false; if(valid(row , column , c)) { //更改 checked[row][column] = true; sudoku[row][column] = c; for(i = 0 ; i < 9 ; i++) { cnt[row][i]--; cnt[i][column]--; } for(i = (row/3) * 3; i < (row/3 + 1) * 3 ; i++) { for(j = (column/3) * 3 ; j < (column/3 + 1) * 3 ; j++) { cnt[i][j]--; } } //递归调用 roadcnt += solve(); // 恢复 for(i = (row/3) * 3; i < (row/3 + 1) * 3 ; i++) { for(j = (column/3) * 3 ; j < (column/3 + 1) * 3 ; j++) { cnt[i][j]++; } } for(i = 0 ; i < 9 ; i++) { cnt[row][i]++; cnt[i][column]++; } sudoku[row][column] = '0'; checked[row][column] = false; } } // roadcnt >= 0 (roadcnt == 0 当且仅当从sudoku[row][column]出发搜索不到任何有效的路径) return roadcnt; } void print() { int i ; for(i = 0 ; i < 9 ; i++) { printf("%s/n" , ans[i]); } } int main() { int n; cin>>n; cin.get(); for(int i = 0 ; i < n ; i ++) { fstwayfound = false; read_init(); solve(); print(); } return 1; }  

// 版本四：智能搜索; AC 228K 47MS ; code length 4054B // 特点 ：改善了版本三混乱的逻辑 ，取消了世纪多余的 checked 数组 // 搜索策略：优先对能够放最少的数字的空格进行填数，以期更早地剪枝 // 备注：为何能更早地剪枝，只是我的一种猜测 // 觉得如果局部的数字越密集，则导致整体的选择范围越小 #include<iostream> using namespace std; char sudoku[9][10];//用于保存输入的数独 char ans[9][10];//用于存放搜索到的完整数独 int cnt[9][9];//cnt[i][j] 用于记录sudoku[i][j] 处能够放置的数字的总数（粗略估计值） bool fstwayfound;// 用于指明已经发现了第一条道路 void read_init() { int i ,j , row ,column; for(i = 0 ;i < 9 ; i++) { scanf("%s" , sudoku[i]); } memcpy(ans , sudoku , sizeof(ans)); for(row = 0; row < 9; row++) { for(column = 0; column < 9; column++) { cnt[row][column] = 9; } } for(row = 0; row < 9; row++) { for(column = 0; column < 9; column++) { if(sudoku[row][column] != '0') { i = 0; //(row,column)所在行，所在列 while(i <= 8) { cnt[i][column]--; cnt[row][i]--; i++; } //(row ,column)所在的小矩阵 for(i = (row/3)*3; i < (row/3 + 1)*3; i++) { for(j = (column/3)*3; j < (column/3 + 1)*3; j++) { cnt[i][j]--; } } } } } } //功能：根据某种策略得到下一个“需要”填数的位置 //输入：引用变量(row ,column) //输出: 如果能够得到下一个位置，则(row , column)记录其行和列 //返回值：如果能够找到这样一个位置，返回 true ，否则 false bool getnxt(int & row ,int & column) { row = column = -1; int mini = 10; int i , j; for(i = 0 ; i < 9 ; i++) { for(j = 0 ;j < 9 ; j++) { if(mini > cnt[i][j] && sudoku[i][j] == '0') { mini = cnt[i][j]; row = i ; column = j; } } } if(row == -1) { return false; } return true; } //功能：将数独(row ,column) 处字符设为 char_to_fill // 并修改cnt数组的值 //输入：row ,column , char_to_fill //输出：无 //返回值：无 //前件：char_to_fill 属于['1' ... '9'] // row ,column 属于[0..8] // sudoku[row][column] == '0' //后件：cnt 改变 ; sodoku[row][column]变为char_to_fill //！！！另外，本函数与reset(row ,column , char_to_fill)对称地执行，对cnt的修改是相反的 void fill(int row , int column , char char_to_fill) { sudoku[row][column] = char_to_fill; int i = 0 , j = 0; while(i <= 8) { cnt[i][column]--; cnt[row][i]--; i++; } for(i = (row/3)*3; i < (row/3 + 1)*3; i++) { for(j = (column/3)*3; j < (column/3 + 1)*3; j++) { cnt[i][j]--; } } } void reset(int row ,int column , char char_to_fill) { sudoku[row][column] = char_to_fill; int i = 0 , j = 0; while(i <= 8) { cnt[i][column]++; cnt[row][i]++; i++; } for(i = (row/3)*3; i < (row/3 + 1)*3; i ++) { for(j = (column/3)*3; j < (column/3 + 1)*3; j++) { cnt[i][j]++; } } } bool valid(int row ,int column ,char char_to_fill) { int i = 0; int j = 0; while(i <= 8) { if(sudoku[i][column] == char_to_fill || sudoku[row][i] == char_to_fill) { return false; } i++; } for(i = (row/3)*3; i < (row/3 + 1)*3; i++) { for(j = (column/3)*3; j < (column/3 + 1)*3; j++) { if(sudoku[i][j] == char_to_fill) return false; } } return true; } void print() { int i; for(i = 0; i < 9 ;i++) { printf("%s/n" , ans[i]); } } //solve 函数的算法流程，假定要搜索所有路径 //按照某种策略找到下一个需要填数的位置(row , column) //if 所有位置都已填数 // 保存路径 // return 1,表示搜到一条路径; //else // roadcnt = 0;//统计路径数 // 对字符 c 取遍 '1' 到 '9' // begin // if c 可以放置在那个位置(row , column) // 将该位置(row ,column)的字符设为 c // 路径数 roadcnt = solve(); // 将该位置(row ,column)的字符恢复为 '0' // end // end // return roadcnt; //end //扩展性： //如果要找到所有路径，可以删除如下代码： // if(fstwayfound) //solve()中 // return 0; // fstwayfound = true; // solve()中 // fstwayfound = false ; // main()中 int solve() { int row ,column; //如果已经找到了第一条路，就不用继续找了 if(fstwayfound) return 0; if(!getnxt(row ,column)) { //如果要找到所有路径，则删去下面这行 fstwayfound = true; memcpy(ans , sudoku , sizeof(ans)); return 1; } int roadcnt = 0; char c; for(c = '1' ; c <= '9' ; c++) { if(valid(row ,column , c)) { fill(row , column , c); roadcnt += solve(); reset(row ,column , '0'); } } return roadcnt; } int main() { int n ; /*scanf("%d/n" , &n);*/ cin>>n; cin.get(); for(int i = 0; i < n; i++) { fstwayfound = false; read_init();//读入并初始化 solve(); print(); } return 1; }