AcWing 166 数独

题目描述:

数独是一种传统益智游戏,你需要把一个9 × 9的数独补充完整,使得图中每行、每列、每个3 × 3的九宫格内数字1~9均恰好出现一次。

请编写一个程序填写数独。

输入格式

输入包含多组测试用例。

每个测试用例占一行,包含81个字符,代表数独的81个格内数据(顺序总体由上到下,同行由左到右)。

每个字符都是一个数字(1-9)或一个”.”(表示尚未填充)。

您可以假设输入中的每个谜题都只有一个解决方案。

文件结尾处为包含单词“end”的单行,表示输入结束。

输出格式

每个测试用例,输出一行数据,代表填充完全后的数独。

输入样例:

4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......
......52..8.4......3...9...5.1...6..2..7........3.....6...1..........7.4.......3.
end

输出样例:

417369825632158947958724316825437169791586432346912758289643571573291684164875293
416837529982465371735129468571298643293746185864351297647913852359682714128574936

分析:

本题要求实现的数独是各行各列以及各九宫格都不能有重复的数字,而且是多组测试用例,对时间要求很高。

方法一:DFS

首先介绍普通的暴搜,就是自左而右,自上而下的去填充数字,直到找到最优解为止。状态表示可以用状态压缩实现,要想在某个位置上填充x,就需要判断x是否在同一行、同一列以及同一个九宫格出现过。以r[i]表示第i行的状态为例,r[i] = 100010001表示第i行1,5,9已经被填充了,我们如果想在第i行的某个空位上填充k,就需要先判断r[i] >> k & 1是否为0,只有r[i]的第k位是0才可以填充,当然,还需要用c[i]表示第i列的状态。一共有9个九宫格,也用0-8去编号下,再用w[i]表示第i个九宫格的状态。只要k在同一行、同一列、同一个九宫格都没有出现过,就可以去填充了。这里实现的细节要注意,为了方便,读入时比如第0行填充了3,我们需要写成r[0] += 1 << 3;就算1-9全部填满,也只是把二进制的1-9位全部置为了1,而第0位我们不用去管它,也就是说,实际上我们是维护一个宽度为10的二进制数,然后只去考虑第1-9位上的数是否为1。

dfs的过程为:找到一个空位,枚举1-9,当这个数不曾出现在同一行、同一列、同一九宫格的时候就填充这个数,并且把该行、该列、该九宫格这个数对应的二进制位置1,然后遍历下一个位置,遍历完后也要恢复所有全局数组的状态。

另外,由于每个数独的答案可能不唯一,找到其中一个就可以返回,不用继续dfs了。如果只有单个输入,找到解后直接exit(0)即可,但是本题是多组用例,所以为了让dfs尽快返回,让递归栈里的内容快速弹出,这里在找到最优解后设置一个标志变量flag的值为true,后面dfs只要遇见flag是true的情况直接返回即可。具体实现细节见代码:

#include 
#include 
#include 
using namespace std;
const int N = 10;
int g[N][N],r[N],c[N],w[N];
bool flag;
int get(int x,int y){//返回九宫格的编号
    x /= 3,y /= 3;
    return x * 3 + y;
}
void dfs(int x,int y,int s){
    if(flag)    return;
    if(!s){//没有空格子了
        for(int i = 0;i < 9;i++){
            for(int j = 0;j < 9;j++){
                cout<>i & 1) && !(c[y]>>i & 1) && !(w[u]>>i & 1)){
                r[x] += 1 << i;
                c[y] += 1 << i;
                w[u] += 1 << i;
                g[x][y] = i;
                dfs(nx,ny,s - 1);
                r[x] -= 1 << i;//恢复状态
                c[y] -= 1 << i;
                w[u] -= 1 << i;
                g[x][y] = 0;
            }
        }
    }
    else    dfs(nx,ny,s);
}
int main(){
    string str;
    while(cin>>str && str[0] != 'e'){
        memset(g,0,sizeof g);
        memset(r,0,sizeof r);
        memset(c,0,sizeof c);
        memset(w,0,sizeof w);
        flag = false;
        int s = 0;
        for(int i = 0;i < str.size();i++){
            if(str[i] == '.'){
                s++;
                continue;
            }
            int x = i / 9,y = i % 9;
            g[x][y] = str[i] - '0';
            r[x] += 1 << g[x][y];
            c[y] += 1 << g[x][y];
            int u = get(x,y);
            w[u] += 1 << g[x][y];
        }
        dfs(0,0,s);
    }
    return 0;
}

方法二:DFS + 优化搜索顺序剪枝

上面的代码虽然思路比较简洁,按顺序去dfs,在本题中却会超时,当然,如果不是多组测试用例肯定不会超时的,因此,需要进行剪枝。首先要注意到按顺序dfs可能会造成很大的冗余。比如说一个数独初始时最后一行除了第一列都已经有数字了,只剩下2可以被填充到第一个位置了。如果是我们人去写数独,肯定是先写这种可以填充的数是唯一的位置,然后再去写其他位置。为什么我们会采取这样的策略呢?一开始我们就知道最后一行第一列只能填充2,所以其他行的第一列都不能填2,否则就找不到解了。但是方法一的这种搜索必然会导致,枚举第一行第一列时填个2,此时没有违背数独的规则,然后沿着搜索树中2后面的分支搜索个遍,没找到答案再去改第一行第一列上的数。不止如此,dfs在枚举第二行、第三行一直到第八行第一列位置上的数时也都会考虑2,这将耗费大量的时间。如果我们最先枚举的就是最后一行第一列,先把2填进去,这些冗余都是可以避免的,所以,本题搜索顺序很重要。我们应该优先搜索能填数字少的地方。

方法一中,在枚举(x,y)上能填充的数字时,我们是先看这个数字是否在第x行、第y列、第u个九宫格中出现过,设此时行、列、九宫格的状态分别是r、c和w,也就是说。我们是判断r中第k为是0,c中第k位是0,w中第k为也是0才去填充k的。设st = r | c | w,三个对应位都是0的位置才能够填充,因此只要三种状态或起来的状态st的第k为是0就可以填充了,st状态中有几个0,就代表这个位置可以填几种数,我们需要优先枚举0最少也就是1最多的状态。换而言之,就是要遍历数独中所有的空位,找到这些位置中st状态中1最多的位置优先填充。一个二进制数中有多少个1,可以先预处理出来。前面说过,这里状态表示实际上是用了10位的二进制数,所以将2^10 = 1024种状态中1的个数都记录下来即可。统计1的个数用lowbit运算即可,比较简单这里不再赘述了。

#include 
#include 
#include 
using namespace std;
const int N = 10,M = 1 << 10 + 1;
int g[N][N],r[N],c[N],w[N],one[M];
bool flag;
int get(int x,int y){
    x /= 3,y /= 3;
    return x * 3 + y;
}
void dfs(int s){
    if(flag)    return;
    if(!s){
        for(int i = 0;i < 9;i++){
            for(int j = 0;j < 9;j++){
                cout< res){//找到1最多的位置
                st = t;
                res = one[t];
                x = i,y = j;
            }
        }
    }
    int u = get(x,y);
    for(int i = 1;i <= 9;i++){
        if(!(st >> i & 1)){
            r[x] += 1 << i;
                c[y] += 1 << i;
                w[u] += 1 << i;
                g[x][y] = i;
                dfs(s - 1);
                r[x] -= 1 << i;
                c[y] -= 1 << i;
                w[u] -= 1 << i;
                g[x][y] = 0;
        }
    }
}
int main(){
    string str;
    for(int i = 0;i < 1 << 10;i++){//预处理1的个数
        int j = i;
        while(j){
            j -= (-j) & j;
            one[i]++;
        }
    }
    while(cin>>str && str[0] != 'e'){
        memset(g,0,sizeof g);
        memset(r,0,sizeof r);
        memset(c,0,sizeof c);
        memset(w,0,sizeof w);
        flag = false;
        int s = 0;
        for(int i = 0;i < str.size();i++){
            if(str[i] == '.'){
                s++;
                continue;
            }
            int x = i / 9,y = i % 9;
            g[x][y] = str[i] - '0';
            r[x] += 1 << g[x][y];
            c[y] += 1 << g[x][y];
            int u = get(x,y);
            w[u] += 1 << g[x][y];
        }
        dfs(s);
    }
    return 0;
}

 

 

你可能感兴趣的:(算法提高课,DFS,剪枝,状态压缩)