如果运气好也是错，那我倒愿意错上加错！

2924 数独挑战

 

 时间限制: 1 s

 空间限制: 1000 KB

 题目等级 : 钻石 Diamond

 

题目描述 Description

“芬兰数学家因卡拉，花费3个月时间设计出了世界上迄今难度最大的数独游戏，而且它只有一个答案。因卡拉说只有思考能力最快、头脑最聪明的人才能破解这个游戏。”这是英国《每日邮报》2012年6月30日的一篇报道。这个号称“世界最难数独”的“超级游戏”，却被扬州一位69岁的农民花三天时间解了出来。

看到这个新闻后，我激动不已，证明我们OI的实力的机会来了，我们虽然不是思考能力最快、头脑最聪明的人，但是我们可以保证在1s之内解题。

好了废话不多说了……

数独是一种填数字游戏，英文名叫Sudoku，起源于瑞士，上世纪70年代由美国一家数学逻辑游戏杂志首先发表，名为Number Place，后在日本流行，1984年将Sudoku命名为数独，即“独立的数字”的省略，解释为每个方格都填上一个个位数。2004年，曾任中国香港高等法院法官的高乐德(Wayne Gould)把这款游戏带到英国，成为英国流行的数学智力拼图游戏。

　　玩家需要根据9×9盘面上的已知数字，推理出所有剩余位置（数据表示为数字0）的数字，并满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。

现在给你一个数独，请你解答出来。每个数独保证有解且只有一个。

输入描述 Input Description

9行9列。

每个数字用空格隔开。0代表要填的数

行末没有空格，末尾没有回车。

输出描述 Output Description

输出答案。

排成9行9列。

行末没有空格，结尾可以有回车。

样例输入 Sample Input

2 0 0 0 1 0 8 9 0
0 0 7 0 0 0 0 0 0
0 0 0 9 0 0 0 0 7
0 6 0 0 0 1 3 0 0
0 9 0 7 3 4 0 8 0
0 0 3 6 0 0 0 5 0
6 0 0 0 0 2 0 0 0
0 0 0 0 0 0 1 0 0
0 5 9 0 8 0 0 0 3

样例输出 Sample Output

2 4 5 3 1 7 8 9 6
9 1 7 2 6 8 5 3 4
3 8 6 9 4 5 2 1 7
4 6 2 8 5 1 3 7 9
5 9 1 7 3 4 6 8 2
8 7 3 6 2 9 4 5 1
6 3 8 1 7 2 9 4 5
7 2 4 5 9 3 1 6 8
1 5 9 4 8 6 7 2 3

数据范围及提示 Data Size & Hint

保证有解，每个数独都由<a href="http://oubk.com/">http://oubk.com</a>数独网提供。

其中数据hard1.in为芬兰数学家提供。

分类标签 Tags 点此展开 

三种做法+超详细注释~

代码：

#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 9;
const int Group[9][9] =
{
    //便于找出是否在同一个9*9的里面出现过
    0, 0, 0, 1, 1, 1, 2, 2, 2,
    0, 0, 0, 1, 1, 1, 2, 2, 2,
    0, 0, 0, 1, 1, 1, 2, 2, 2,
    3, 3, 3, 4, 4, 4, 5, 5, 5,
    3, 3, 3, 4, 4, 4, 5, 5, 5,
    3, 3, 3, 4, 4, 4, 5, 5, 5,
    6, 6, 6, 7, 7, 7, 8, 8, 8,
    6, 6, 6, 7, 7, 7, 8, 8, 8,
    6, 6, 6, 7, 7, 7, 8, 8, 8
};

int a[N][N];
int row[N][N], col[N][N], gr[N][N];//行 列 3*3矩阵

int judge()
{
    int vis[N];

    for(int i=0; i<N; i++)//行
    {
        for(int j=0; j<N; j++) vis[j] = 0;
        for(int j=0; j<N; j++) vis[a[i][j]] = 1;
        for(int j=0; j<N; j++) if(!vis[j]) return 0;
    }

    for(int i=0; i<N; i++)//列
    {
        for(int j=0; j<N; j++) vis[j] = 0;
        for(int j=0; j<N; j++) vis[a[j][i]] = 1;
        for(int j=0; j<N; j++) if(!vis[j]) return 0;
    }

    for(int i=0; i<N; i++)//3*3矩阵
    {
        for(int j=0; j<N; j++) vis[j] = 0;
        for(int j=0; j<N; j++)
        for(int k=0; k<N; k++)
            if(Group[j][k] == i)
                vis[a[j][k]] = 1;
        for(int j=0; j<N; j++)
            if(!vis[j])
                return 0;
    }
    return 1;
}

void print()
{
    //printf("One Possible Solution:
");
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++)
            printf("%d ", a[i][j] + 1);//因为输入时减去了1
        printf("
");
    }
}

void dfs1(int x, int y)
{
    if(x == N)//胜利条件 
    {
        if(judge()) print();//进行判断当前所形成的9*9是否满足条件 
        return;
    }

    int next_x = x, next_y = y + 1;
    if(next_y == N) next_x = x + 1, next_y = 0;//继续下一行 

    if(a[x][y] >= 0) dfs1(next_x, next_y);//如果当前位置搜索过了 
    else
    {
        for(int i=0; i<N; i++)
        {
            a[x][y] = i;//先赋值 
            dfs1(next_x, next_y);//继续搜索 
        }
    }
}

void dfs2(int x, int y)
{
    if(x == N)//胜利条件 
    {
        print();
        return;
    }

    int next_x = x, next_y = y + 1;
    if(next_y == N) next_x = x + 1, next_y = 0;//进行下一行的搜索 

    if(a[x][y] >= 0) dfs2(next_x, next_y);//如果当前的数字被搜索过了 
    else
    {
        for(int i=0; i<N; i++)
        {
            a[x][y] = -1;//初始化

            int okay = 1;
            for(int j=0; j<N && okay; j++)
                if(a[j][y]==i)//当前一列出现过该数字
                    okay = 0;//不满足，进行标记
            for(int j=0; j<N && okay; j++)
                                   if(a[x][j]==i)//当前一行出现过该数字
                    okay = 0;
            for(int j=0; j<N && okay; j++)
                for(int k=0; k<N && okay; k++)//该3*3矩阵中出现过该数字
                    if(Group[j][k]==Group[x][y] &&
                            a[j][k]==i) okay = 0;

            if(okay)//如果搜索过后满足条件
            {
                a[x][y] = i;//记录下来
                dfs2(next_x, next_y);//进行下一步的搜索
            }
        }

        a[x][y] = -1;//回溯
    }
}

void dfs3(int x, int y)
{
    if(x == N)//胜利条件 
    {
        print();
        return;
    }

    int next_x = x, next_y = y + 1;//一行一行进行搜索 
    if(next_y == N) next_x = x + 1, next_y = 0;

    if(a[x][y] >= 0) dfs3(next_x, next_y);//该行搜索完成，进行下一行的搜索 
    else
    {
        for(int i=0; i<N; i++)
            if(!row[x][i] && !col[y][i] && !gr[Group[x][y]][i])
            {
                row[x][i] = col[y][i] = gr[Group[x][y]][i] = 1;
                a[x][y] = i;//记录下数字
                dfs3(next_x, next_y);
                a[x][y] = -1;//回溯
                row[x][i] = col[y][i] = gr[Group[x][y]][i] = 0;
            }
    }
}

int main()
{
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            scanf("%d", &a[i][j]), a[i][j]--;//因为是从0号开始的
    
            /* 3种做法 */

    //printf("Dfs Method1:
");
    //dfs1(0, 0);

    //printf("Dfs Method2:
");
    //dfs2(0, 0);

    //printf("Dfs Method3:
");

    for(int i=0; i<N; i++)//(将一开始就有的数字进行标记)
        for(int j=0; j<N; j++)//双层循环 
            if(a[i][j] >= 0)//如果他是数字，那么相应的进行标记 
                row[i][a[i][j]] = 1,//该行该数字已经出现过 
                   col[j][a[i][j]] = 1,//该列该数字已经出现过 
                      gr[Group[i][j]][a[i][j]] = 1;
    //3*3矩阵的分类，标记在当前的3*3矩阵中该数字已经出现过了 

    dfs3(0, 0);//从头开始进行搜索 

    return 0;
}