抽象DFS: 数独

简介: 抽象DFS: 数独

蒜头君今天突然开始还念童年了,想回忆回忆童年。他记得自己小时候,有一个很火的游戏叫做数独。便开始来了一局紧张而又刺激的高阶数独。蒜头君做完发现没有正解,不知道对不对? 不知道聪明的你能否给出一个标准答案?


标准数独是由一个给与了提示数字的 9×9 网格组成,我们只需将其空格填上数字,使得每一行,每一列以及每一个 3×3 宫都没有重复的数字出现。

输入:


* 2 6 * * * * * *


* * * 5 * 2 * * 4


* * * 1 * * * * 7


* 3 * * 2 * 1 8 *


* * * 3 * 9 * * *


* 5 4 * 1 * * 7 *


5 * * * * 1 * * *


6 * * 9 * 7 * * *


* * * * * * 7 5 *


输出:


1 2 6 7 3 4 5 9 8


3 7 8 5 9 2 6 1 4


4 9 5 1 6 8 2 3 7


7 3 9 4 2 5 1 8 6


8 6 1 3 7 9 4 2 5


2 5 4 8 1 6 3 7 9


5 4 7 2 8 1 9 6 3


6 1 3 9 5 7 8 4 2


9 8 2 6 4 3 7 5 1

#include <iostream>
using namespace std;
char a[10][10];
bool f;
bool hang[10][10],lie[10][10],ge[10][10];
void dfs(int x,int y){
  if(f){                         //f在这里意思是,已经找到解,无需继续搜素(剪枝)
    return;
  }
  if(x==9){
    f=true;
    cout<<"--------------------"<<endl;
    for(int i=0;i<9;i++){
      for(int j=0;j<9;j++){
        if(j!=8){
          cout<<a[i][j]<<' ';
        }else{
          cout<<a[i][j]<<endl;
        }
    }
  }
  return;
}
  if(y==9){                           //y=9时进入下一行
    dfs(x+1,0);
    return;
  }
  if(a[x][y]!='*'){                   //x行y列是数字无需进行判断
    dfs(x,y+1);
    return;
  }
  for(int i=1;i<=9;i++){
    if(!hang[x][i] && !lie[y][i] && !ge[(x/3)*3+y/3][i]){
      a[x][y]='0'+i;
      hang[x][i]=true;
      lie[y][i]=true;
      ge[(x/3)*3+y/3][i]=true;
      dfs(x,y+1);
      hang[x][i]=false;
      lie[y][i]=false;
      ge[(x/3)*3+y/3][i]=false;
      a[x][y]='*'; 
    }
  } 
}
int main(){
  for(int i=0;i<9;i++){
    for(int j=0;j<9;j++){
      cin>>a[i][j];
    }
  }
  for(int i=0;i<9;i++){
    for(int j=0;j<9;j++){
      if(a[i][j]!='*'){
        hang[i][a[i][j]-'0']=true;   //第i行,a[i][j]不可用 
        lie[j][a[i][j]-'0']=true;    //第j列,a[i][j]不可用 
        ge[(i/3)*3+j/3][a[i][j]-'0']=true;  //自上向下,自左向右,分为9个格。 
      }
    }
  }
  dfs(0,0);             //c从0行0列开始搜索 
  return 0;
}

相关文章
|
7月前
|
算法
Hierholzer算法dfs找欧拉回路模板
Hierholzer算法dfs找欧拉回路模板
79 0
|
7月前
【错题集-编程题】体操队形(DFS + 枚举)
【错题集-编程题】体操队形(DFS + 枚举)
|
存储 算法
深度优先遍历(DFS):探索图的奥秘
当进行深度优先遍历(DFS)时,我们需要按照一定的步骤来遍历图中的节点。 选择起始节点:选择图中的一个起始节点作为遍历的起点。 标记已访问:将起始节点标记为已访问,并将其放入数据结构中,比如栈或递归调用。 探索相邻节点:从起始节点开始,探索与其相邻的节点。这是通过查找邻接表来实现的,邻接表存储了每个节点的相邻节点信息。 深入探索:选择一个相邻节点,标记为已访问,并将其放入数据结构中。然后,从这个相邻节点出发,继续探索其相邻节点,形成一个深入的路径。这一步是递归的核心。 回溯:当没有未访问的相邻节点时,回溯到上一个节点,继续探索其他未访问的相邻节点。这可以通过从数据结构中弹出节点来实现,或者从递
313 0
|
机器学习/深度学习 存储 算法
【DFS经典例题】2n皇后问题
【DFS经典例题】2n皇后问题
82 0
|
数据采集 算法 C++
DFS(深度优先搜索)详解(概念讲解,图片辅助,例题解释,剪枝技巧)
DFS(深度优先搜索)详解(概念讲解,图片辅助,例题解释,剪枝技巧)
1163 0
|
机器学习/深度学习
抽象DFS:2N皇后
抽象DFS:2N皇后
|
机器学习/深度学习
抽象DFS:N皇后问题
抽象DFS:N皇后问题