求解数独

最新推荐文章于 2021-02-02 09:48:57 发布
最新推荐文章于 2021-02-02 09:48:57 发布
阅读量1k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： search 网易 class 算法 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/iamyuguo/article/details/2088631
数独是一种折磨人的游戏，感兴趣却不懂者随便baidu一下就知道其规则了

我的这个解法原理是先根据数独的规则，找出能快速确定的数字：
    1，这一点能且仅能取某值；
    2，这一行 / 列 / 格 没有其他的点能取某值。

然后如果没有解出该数独则再用回溯法搜索解空间。

此算法的效率相当不错。


class sudoku
{
    char board_map [9][9];//盘面
    char background[9][9];//作为记录scan结果用的盘面
    bool possible  [9][9][10];     //某个格子里某个元素是否可能出现
    char remaind   [9][9];        //某个格子中还有几种可能的数字
    void init()
    {
        for(int i=0;i<9;i++)
        {   
            for(int j=0;j<9;j++)
            {
                remaind[i][j]=9;
                for(int k=0;k<=9;k++)possible[i][j][k]=true;
                background[i][j]=0;
            }
        }
    }
 public:
    sudoku(char b[9][9])
    {
        init();
        for(int i=0;i<9;i++)
            for(int j=0;j<9;j++)
                {
                    board_map[i][j]=b[i][j];
                    background[i][j]=0;
                }
    }
    sudoku()
    {
        init();
        for(int i=0;i<9;i++)
            for(int j=0;j<9;j++)
                background[i][j]=board_map[i][j]=0;
    }
    ~sudoku(){}
   
    void get_result(char b[9][9])
    {for(int x=0;x<9;x++)for(int y=0;y<9;y++)b[x][y]= board_map[x][y];}
 private:
    void scan(int x,int y,int n);
    bool trace_back();
 public:
    bool search();
};


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////


void sudoku::scan(int x,int y,int n)
{
    //cout<<"scaning ---> "<<x+1<<','<<y+1<<':'<<n<<'/n';
    if(board_map[x][y]==0) return;
    int i,j,k;
    int box_x=int(x/3) , box_y=int(y/3);
   
//---------------------------------------------------------------------------------
   
    for(i=0;i<9;i++)
    {
        if(possible[i][y][n])
        {
            possible[i][y][n] = false;
            if(remaind[i][y]!=1) remaind[i][y]--;
            if(remaind[i][y]==1 && board_map[i][y]==0)
            {
                for(k=1;k<=9;k++)if(possible[i][y][k]){background[i][y]=k;break;}
            }
        }
    }
    for(j=0;j<9;j++)
    {
        if(possible[x][j][n])
        {
            possible[x][j][n] = false;
            if(remaind[x][j]!=1) remaind[x][j]--;
            if(remaind[x][j]==1 && board_map[x][j]==0)
            {
                for(k=1;k<=9;k++)if(possible[x][j][k]){background[x][j]=k;break;}
            }
        }
    }
    for(i=box_x*3;i<box_x*3+3;i++)
        for(j=box_y*3;j<box_y*3+3;j++)
        {
            if(possible[i][j][n])
            {
                possible[i][j][n] = false;
                if(remaind[i][j]!=1) remaind[i][j]--;
                if(remaind[i][j]==1 && board_map[i][j]==0)
                {
                    for(k=1;k<=9;k++)if(possible[i][j][k]){background[i][j]=k;break;}
                }
            }
        }
    for(k=0;k<=9;k++) possible[x][y][k] = false;
    possible[x][y][n]=true;
    remaind [x][y]=0;
   
//---------------------------------------------------------------------------------
   
    int p=0;
    int ti,tj,tk;
    for(k=1;k<=9;k++)
    {
        p=0;
        for(i=0;i<9;i++)
        {
            if(possible[i][y][k])
            {
                p++;
                ti=i;
                tk=k;
            }
        }
        if(p==1) background[ti][y]=tk;
    }
   
    for(k=1;k<=9;k++)
    {
        p=0;
        for(j=0;j<9;j++)
        {
            if(possible[x][j][k])
            {
                p++;
                tj=j;
                tk=k;
            }
        }
        if(p==1) background[x][tj]=tk;   
    }
   
    for(k=1;k<=9;k++)
    {
        p=0;
        for(i=box_x*3;i<box_x*3+3;i++)
            for(j=box_y*3;j<box_y*3+3;j++)
            {
                if(possible[i][j][k])
                {
                    p++;
                    ti=i;
                    tj=j;
                    tk=k;
                }
            }
        if(p==1) background[ti][tj]=tk;                   
    }
}

bool sudoku::trace_back()//用回溯法进行搜索！
{
    int x=0,y=0,k,n;
    bool find_one=false;

    bool in_column[9][10];//true=>能放入第n行
    bool in_row[9][10];      //true=>能放入第n列
    bool in_box[3][3][10];//true=>能放入第n个格子
    for(n=1;n<=9;n++)//初始化三个可恶的数组
        for(x=0;x<9;x++)
        {
            in_column[x][n]=true;
            in_row[x][n]=true;
            in_box[x/3][x%3][n]=true;
        }
   
    for(n=1;n<=9;n++)
    for(x=0;x<9;x++)
        for(y=0;y<9;y++)
        {
            if(board_map[x][y]==n)
            {
                in_column[x][n]=false;
                in_box[x/3][y/3][n]=false;
                in_row[y][n]=false;
            }
        }
       
    x=0,y=0;     

    while(true)
    {
        if (x<0||y<0)//找到了所有结果
            break;
        if (x>8||y>8)//找到了一个结果 ，这里可以改一下，让他将找到的结果输出，然后继续寻找下一个结果
            break;
       
        while(board_map[x][y]!=0)//到下一个非预设点
        {
            if(++x==9)
            {
                x=0;
                ++y;
            }
            if(y>8) break;
         }    
        
         find_one=false;
        for(n=background[x][y]+1;n<=9;n++)
            if (
                in_column[x][n]&&
                in_row[y][n]&&
                in_box[x/3][y/3][n]
                )//可以放入
            {
                if((k=background[x][y])!=0)
                {
                    in_column[x][k]=true;
                    in_row[y][k]=true;
                    in_box[x/3][y/3][k]=true;
                }
               
                background[x][y]=n;
               
                in_column[x][n]=false;
                in_row[y][n]=false;
                in_box[x/3][y/3][n]=false;
               
                find_one=true;
                break;
            }
       
        if(find_one)
        {
            do    //到下一个非预设点
            {
                if(++x==9)
                {
                    x=0;
                    ++y;
                }
                if(y>8) break;
             } while(board_map[x][y]!=0);
        }
        else
        {//惨了走不动了,那就回去吧！
           
            in_column[x][background[x][y]]=true;
            in_row[y][background[x][y]]=true;
            in_box[x/3][y/3][background[x][y]]=true;
           
            background[x][y]=0;
            do
            {
                if(--x<0)
                {
                    x=8;
                    --y;
                }
                if(y<0)break;
            }while(board_map[x][y]!=0);
        }
    }
   
    int sum=0;
    for(x=0;x<9;x++)for(y=0;y<9;y++)
    {
        if(background[x][y]!=0)board_map[x][y]=background[x][y];
        sum+=board_map[x][y];
    }
    if (sum==45*9) return true;
    else return false;
}


bool sudoku::search()
{
    bool find_ans=false,new_ans_finded;
    int x,y;
    for(x=0;x<9;x++)
        for(y=0;y<9;y++)
            scan(x,y,board_map[x][y]);
    do
    {
        new_ans_finded=false;
        for(x=0;x<9;x++)
            for(y=0;y<9;y++)
            {
                if (background[x][y]!=0&&board_map[x][y]==0)
                {
                    new_ans_finded=true;
                    board_map[x][y]=background[x][y];
                    scan(x,y,board_map[x][y]);
                    //cout<<"* finded:"<<x+1<<','<<y+1<<':'<<(int)background[x][y]<<'/n';
                }
            }
    }
    while (new_ans_finded);
    unsigned int sum=0;
    for(x=0;x<9;x++)for(y=0;y<9;y++)sum+=board_map[x][y];
    if (sum==45*9) return true;
    else return trace_back();//此路不通，换一条试试！
}


我把这篇文章发表到网易博客时被人批评说注释太少——是太少了，凑合着看吧


另外给出一个简单的主函数，大家可以用来验证一下它的正确性以及效率：


int main()
{

 char s[4][9][9]=
 {
  0,2,0, 0,0,0, 0,0,0,
  0,0,1, 5,0,0, 0,0,2,
  0,6,0, 7,0,0, 0,0,0,
  
  1,0,0, 3,0,0, 0,0,0,
  0,7,8, 0,0,2, 0,0,0,
  0,0,5, 0,9,0, 0,0,3,
  
  7,0,4, 0,0,0, 0,8,6,
  0,0,0, 0,3,0, 5,1,0,
  0,0,0, 4,1,0, 0,0,0
  
,       ////////////////////

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

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

  0,0,0, 6,0,0, 0,4,0,
  3,2,0, 0,0,0, 0,0,1,
  0,4,8, 0,0,1, 3,0,0,
  
  0,0,0, 5,0,0, 0,7,0,
  8,3,0, 0,1,0, 0,0,5,
  5,0,7, 0,0,6, 1,0,0,
  
  1,5,0, 0,0,8, 6,0,0,
  0,0,0, 0,0,0, 0,0,0,
  4,8,0, 0,0,9, 7,0,0
 };

 sudoku x;
 char t[9][9];
 for(int n=0;n<4;n++)
 {
  x.reset(s[n]);
  if(x.search()) cout<<"answer finded:/n";
  else cout<<"can't find answer/n";
  x.get_result(t);
  
  
  for(int i=0;i<9;i++)
  {
   if(i==0)cout<<"┏━┯━┯━┳━┯━┯━┳━┯━┯━┓/n┃";
   else if(i%3==0)cout<<"┣━┿━┿━╋━┿━┿━╋━┿━┿━┫/n┃";
   else cout<<"┠─┼─┼─╂─┼─┼─╂─┼─┼─┨/n┃";
   for(int j=0;j<9;j++)cout<<(s[n][i][j]?'*':' ')<<int(t[i][j])<<((j+1)%3!=0?"│":"┃");
   cout<<'/n';
  }
  cout<<"┗━┷━┷━┻━┷━┷━┻━┷━┷━┛/n";
 }
 cin.get();
 return 0;
}

Java实现数独的检查(使用HashSet)
allllloo的博客
03-20 347
数独是一种流行的单人游戏。 目标是用数字填充 9×9 矩阵，使每列，每行和所有 9 个非重叠的 3×3 子矩阵包含从 1 到 9 的所有数字。 每个 9×9 矩阵在游戏开始时都会有部分数字已经给出，通常有一个独特的解决方案。 给定完成的 N2×N2 数独矩阵，你的任务是确定它是否是有效的解决方案。 有效的解决方案必须满足以下条件： 每行包含从 1 到 N2 的每个数字，每个数字一次。 每列包含从 1 到 N2 的每个数字，每个数字一次。 将 N2×N2 矩阵划分为 N2 个非重叠 N×N 子矩阵。 每个子矩
数独检查_检查有效的数独
cumtv80668的专栏
07-29 2181
数独检查Problem statement: 问题陈述： Determine if a 9x9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules: 确定9x9数独板是否有效。 仅需根据以下规则验证填充的单元格： Each row must co...
数独检查
weixin_52985599的博客
02-02 1378
数独检查 题目来源：acwing题库 题目地址：https://www.acwing.com/problem/content/705/ 题目描述： 数独是一种流行的单人游戏。 目标是用数字填充9x9矩阵，使每列，每行和所有9个非重叠的3x3子矩阵包含从1到9的所有数字。 每个9x9矩阵在游戏开始时都会有部分数字已经给出，通常有一个独特的解决方案。 给定完成的N2∗N2数独矩阵，你的任务是确定它是否是有效的解决方案。 有效的解决方案必须满足以下条件： 每行包含从1到N2的每个数字，每个数字一次。 每列包含
数独有效性校验
Odew
05-27 5139
数独有效性校验 判断一个 9x9 的数独是否有效。需要根据以下规则，验证已经填入的数字是否有效即可。 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 上图是一个部分填充的有效的数独。 以下输入是一个二维数组，部分元素已填入了数字，空白格用 ‘.’ 表示。 示例 1: 输入: [ ...
检查数独是否有效
gcs的博客
01-29 2507
判断一个9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。 数字1-9在每一行只能出现一次。 数字1-9在每一列只能出现一次。 数字1-9在每一个以粗实线分隔的3x3宫内只能出现一次。 上图是一个部分填充的有效的数独。 数独部分空格内已填入了数字，空白格用'.'表示。 示例1: 输入: [ ["5","3",".",".","7"...
判断数独是否正确
热门推荐
扬帆起航
06-04 1万+
想必大家都玩过数独吧（我竟没玩过.....），在最近的周赛中我就遇到了一个关于数独的问题，给出数独让你判断是否正确，当时a了，可后来经过查询发现当时是由于数据不全面的原因才侥幸通过，下面我就纠正一下我的错误，聪明的你可不要犯和我一样错误吆。 错误！！！的思想： 1，,每列中包含1~9 2，每行中包含1~9 后来才知道原来只满足这两个条件并不能满足每一个九宫格中包含1~9 正解！！
算法题：数独验证
zhibin的程序日记
02-02 2152
背景 XX学校风靡一款智力游戏，也就是数独（九宫格），先给你一个数独，并需要你验证是否符合规则。 描述 具体规则如下: 每一行都用到1,2,3,4,5,6,7,8,9，位置不限， 每一列都用到1,2,3,4,5,6,7,8,9，位置不限， 每3×3的格子（共九个这样的格子）都用到1,2,3,4,5,6,7,8,9，位置不限， 游戏的过程就是用1,2,3,4,5,6,7,8
poj 3435 检测数独状态是否合法
sepNINE的专栏
04-27 1290
题意: 给一个数独的状态，判断它是否合法。 分析： 水，直接判断。 代码： //poj 3435 //sep9 #include using namespace std; const int maxN=10; const int MAX=maxN*maxN+10; int a[MAX][MAX]; int col_check[MAX][MAX]; int row_check[MAX][
解数独程序源代码，可检测题目是否合法，可解无解/一个解/多个解的情况。leetcode测试较快，现在分享，望指教！
fn0723的博客
05-05 1994
//sudoku.cpp// 解数独函数 #include "sudoku.h" #include #include using namespace std; void sudoku(char array[9][9]) { int sudo[9][9]={0}; int number_of_empty=0;
[各种面试题] 检查数独是否正确
a83610312的专栏
09-20 6708
写程序判断一个9*9的数字盘面是否为合法的数独（查看定义）。 9*9的盘面按照Row-major order表示为一个81维的一维数组。 提示：请直接在一维数组上操作，不要先将一维数组拷贝到9*9的二维数组。 犯了两个错，一个是 应该是 row[x] | = ,结果写成&=； 二是要判断 n是否在[1,9]间。 int isValidSudoku(int
Java基础3——检查数独的解决方案是否正确，两种方法
yaocong1993的博客
12-29 5173
检查数独的解决方案是否正确： 数独是一个9x9网格，被分为9个3x3的块。 将1~9输入格子里，使每行每列及每块都包含1~9九个数字。 检查数独的解决方案是否正确有两种方法： 方法1：检查是否每行每列每块都有1~9； 方法2：检查每个单元格，数字必须是1~9，且该数字在每行每列每块都是唯一的。
【vijos】P1335 数独验证
wlxsq的专栏
03-04 1740
背景 XX学校风靡一款智力游戏，也就是数独（九宫格），先给你一个数独，并需要你验证是否符合规则。 描述 具体规则如下: 每一行都用到1,2,3,4,5,6,7,8,9，位置不限， 每一列都用到1,2,3,4,5,6,7,8,9，位置不限， 每3×3的格子（共九个这样的格子）都用到1,2,3,4,5,6,7,8,9，位置不限， 游戏的过程就是用1,2,3,4,5
字符串匹配之Horspool算法
IF
09-12 3650
基于后缀，应该算是Boyer-Moore算法的简化算法，详情——嗯——依然参阅《柔性字符串匹配》这本好书(因为我肯定没法讲得比他清楚)。我的实现如下：templateclass OutputFunctionType >size_t Search_Horspool(const char* Str, const char* T, OutputFunctionType out)//在Str中寻找T，返回
求解马的周游路线
IF
02-12 1484
马的周游路线（knights tour）讲的是在一个国际象棋棋盘上，让一匹马用64步跳完64个格子的问题。我这个算法是按照深度优先算法搜索整个解空间，虽然对于 8*8 的棋盘时间消耗上还算很短，但其效率绝对还是不高的。后来看了易语言的示例，发现其实可以用贪心算法来找到马的周游路线，就是每次都走到剩下可行的步数最少的格子去——但是不理解原理。#include using namespace std
字符串匹配之Shift And算法
IF
09-12 1462
基于前缀的搜索——详情参阅《柔性字符串匹配》这本好书，别的就不多说了直接给出我的实现...template class Output_Function>size_t Shift_And(const char* source,const char* to_find,Output_Function out){/** * 在source中查找to_find，利用out输出每次出现的地方 * 返回to_f
英语的数字——是多少呢
IF
09-12 1155
举个例子，nine hundred and eighty seven million six hundred and fifty four thousand three hundred and twelve，它究竟是多少呢？这种东西简直不是给人看的，所以呢，咱们想一个算法来翻译它吧。首先分析一下上面那个数字——嗯，断句先——nine hundred and eighty seven million
解行列式
IF
02-12 1140
这是我刚开学不久写的解行列式的算法，原理很简单，就是将行列式按行、列展开计算。 #include using std::cin;using std::cout;template void input(int &d,T** &m){    cout>d;    m=new T*[d];    for (int i=0;i    cout    for (int i=0;i       
POJ 1011 Sticks
IF
05-17 982
 写这篇文章呢，有个很邪恶的目的，就是提高博客的访问量——据我所知“POJ 1011”这个关键词似乎非常极其的热门——是不是？当时我做这题的时候的确就写了下面这么长的代码，不过你读一遍就会发现 3/4 的内容都被注释掉了，那些内容多少能说明我的思想，而剩下来的那部分是可以 AC 的。PS. 我真的不喜欢全局变量。PPS. 以后这里不会再放ACM的代码了；感兴趣的话可以等河蟹
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值