POJ 2676 Sudoku

Sudoku

回溯题目，求解一个可行解，类似于8皇后问题。规则很简单，也是类似于8皇后的规则。玩过数独就很容易理解题意了。给定一个没有填写完整的数独，找出一个可行解即可。

标记每行每列以及3*3小矩阵的哪些数字已经被放过，每次放置前先检查是否合法(不出现重复数字)，然后放置。

#include<iostream>
#include<cstring>
#include<cstdio>

using namespace std ;

#define HASH(i , j) (i / 3) * 3 + ( j / 3 )

struct Node{
    bool a[10] ;
    void init(){
        memset(a , 0 , sizeof(a) ) ;
    }
};

int map[10][10] ;

Node x[10] ;//用于判断行中哪些数字已经出现过
Node y[10] ;//用于判断劣种哪些数字已经出现过
Node z[10] ;//用于判断子正方形中哪些数字已经出现过

int n ;


//打印输出结果
void print( ){
    for(int i = 0 ; i < 9 ; i ++){
        for(int j = 0 ; j < 9 ; j ++){
            printf("%d" , map[i][j]) ;
        }
        printf("\n") ;
    }
}

int dfs(int pos){

    //确定sx，sy
    int sx = pos / 9 ;
    int sy = pos % 9 ;
    //注意此处的判断条件
    if(pos==81){
        return 1 ;
    }

    //此处已经有数
    if(map[sx][sy] != 0){
        return dfs(pos + 1) ;
    }

    for(int i = 1 ; i <= 9 ; i ++){
        //如果该格子所在的行列以及子格子
        //已经含有对应的数字将过滤
        int h = HASH(sx , sy) ;
        
        //判断放置次数是否合法，如果合法则可以放置，如果不合法则继续下一次试探
        if(x[sx].a[i] == 1 || y[sy].a[i] == 1 || z[h].a[i] == 1 ){
            continue ;
        }
        
        else{
            x[sx].a[i] = 1 ;
            y[sy].a[i] = 1 ;
            z[h].a[i] = 1  ;

            map[sx][sy] = i ;

            if(dfs(pos + 1)==1){
                return 1 ;
            }

            map[sx][sy] = 0 ;
            x[sx].a[i] = 0 ;
            y[sy].a[i] = 0 ;
            z[h].a[i] = 0 ;

        }
    }

    return 0 ;

}


int main(){

    scanf("%d" , &n) ;
    char c ;
    getchar() ;
    int sx ;
    int sy ;
    bool flag ;

    while(n--){
        //读入多余的回车


        //初始化
        for(int i = 0 ; i <= 9 ; i ++){
            x[i].init() ;
            y[i].init() ;
            z[i].init() ;
        }

        sx = 0 ;
        sy = 0 ;
        memset(map , 0 , sizeof(map)) ;

        flag = 0 ;

        for(int i = 0 ; i < 9 ; i ++){
            for(int j = 0 ; j < 9 ; j ++){
                c = getchar() ;

                map[i][j] = c - '0' ;

                //x方向标志为1

                x[i].a[ map[i][j] ] = 1 ;
                y[j].a[ map[i][j] ] = 1 ;

                //投影计算
                int k = HASH(i , j) ;
                //记录对应的值
                z[k].a[ map[i][j] ] = 1 ;
                //找到一个空点
                if( map[i][j] == 0 && !flag){
                    sx = i ;
                    sy = j ;
                    flag = 1 ;
                }
            }
            getchar() ;
        }

        if(flag){
            dfs( sx * 9 + sy ) ;
        }

        print() ;


    }
    return 0 ;
}