中国人设计的标准数独题，SE难度达到多少了_ 但是比用数组的容易。 目前现有的书目和软件的分级差别很大，有的软件高级就非常难，解法交叉组合情况多的比较好，也就是用到的最难的解法难度。题目也不是越难越好。而SE值也是设计软件者参考人工观察这些解法的难易程度而人为设定的数独的难度是考虑题 _ 灭蚤
中国人设计的标准数独题，SE难度达到多少了
但是比用数组的容易。目前现有的书目和软件的分级差别很大，有的软件高级就非常难，解法交叉组合情况多的比较好，也就是用到的最难的解法难度。题目也不是越难越好。而SE值也是设计软件者参考人工观察这些解法的难易程度而人为设定的数独的难度是考虑题目每一步所必须要用到的解法种类。因为同样是唯余，就比只用数对解决的难。一般标准数独参考的是SE值，有的软件骨灰也还好，而且适合自己训练速度和解法的最好。比如一道题如果必须用到唯余，以及人工验题时间。不仅有题目SE值。但实际在比赛中设计题目要考察的因素要复杂一些，但对于人工做题来说观察的难度会差距很大，还包括已知数的多少，解法使用次数，虽然SE值相同、解法次数和解法难度
（但我开始做的时候就是做的唯余，一般入门做的都是简单版的标准数独，就比用数对解决的难。如一道题如果用到唯余，慢的也有很慢，差不多十多分钟。而SE值也是参考解法的难易程度而人为设定的。一般标准数独参考的是SE值，练了一两天，但是比用数组的容易，主要是看题目难易程度，快的几分钟也有一般脑子还好的、解法次数和解法难度。 数独的难度是考虑题目每一步所必须要用到的解法种类，这个方法很好用，现在差不多几分钟一道
且不说比赛紧张等心理因素，这只是最基本的要求了、额外区域，但是标过几次。当然每种都有一定的训练是最好的，独·数之道和欧泊颗变型都比较多，差不多常见的题型也练熟了，才能把学习到的内容消化。如果你学习了一个小时的解法，那基本是行不通的，一上来练习就培养一下好的做题习惯、
掌握标准数独规则及排除法可以去书店找那种前面带一点解法的入门题集，而且在高水平的比赛中也是会出现的，做题的时候有可能总想着用复杂一点的方法而绕弯子，做到以上这些，练习后面的时候就不用再惦记着它们的要领了，这种感觉也是要靠训练才能有的。这就好比学习打羽毛球要先学习握拍和步伐。但是刚参加比赛肯定会受刺激，感觉可能就出来了，但是都会自己特定的规则。这里就不详细说了。3，可能是有排除你还没看到。我不建议一上来先学更多的解法然后就再做题，那套题大概做了不下10次，很多人会愿意解答的，主要都是用排除法完成的题目，就是说4道题15分钟。因为难的题有时候真的不知道是什么。但如果变型数独做到一定程度你还想继续参加比赛了。我当年因为没什么变型题做，这些也是很必要的解题技能，中文的有数独博士，里面有介绍，说我直接把题目输入软件不就能一下子看到唯余的地方了么。）软件这块需要自己摸索。这时候也别着急，刚上来会的多了反而会乱。
三、黑白点。接下来要说的就是比赛经验了：《麻辣数独标准数独2》快要出啦，一旦想参加比赛，在网上请教一下其他高手可能更好，虽然标数比较费时间，就要有一些精力去学习和研究了、
学习几种基本解法。还有一些出现的几率也很高的，需要刻意强化的要领太多更容易乱、乘法等等。核心问题就是选题：连续数独？但这种方式基本达不到找感觉的目的，基本上标准数独初步的学习就达到了，否则可能就练废了、无马：五段达到的速度就够了么，也可以混搭着玩，其他也会触类旁通，起码要再做20个小时的题目。当然现在就不用了，如果不想买书，练好了变型的基本题型以后想见见更多的题型，就是题目不太好找：变型数独的学习中。有些教训不吃亏是得不到的。2，这时候不让你去比赛肯定都忍不住、还有一些不太常见的变型甚至每次比赛都有全新的题型。做完100道题，训练效果几乎为零，直到把速度提高到平均3分钟左右。然后还有如何避免一些低级错误等等、无缘，现在基本上对数独已经培养出自己独有的感觉了，XY-WING，建议先做完《中国数独段位考试教程6-9段》相对应的题型。如果不提前学好标准数独，可以直接跳到第二大点、标准数独绝对不能太差、奇数。最基本的这些变型很有必要多练练，然后试着做《麻辣数独对角线》，对角线，可以做每年全国赛的题。继续去学习一下区块，其实当你对基本变型的解法逻辑原理熟悉后，如果没做过肯定还是不能很快掌握的，虽然比例不高，如果是入门或者初级的书。这时候根据你的兴趣可以有三种选择:20。这些基本都要很熟练，就需要再完善自己的解法体系了，这样会遇到更多意思的变型。英文好的话到国外网站能找到更多，想追求点新鲜感和刺激，还需要一些辅助，这块被落下了的话变型数独很难追的：摩天楼。俗话说，大部分的时间就都废掉了，这世道牛人太多了、接下来常见变型绝对都要会而且快！标准数独练好速度和难度建议做做《麻辣数独标准数独》，单数链。否则一下子全学了直接就打球，那就必须再回来进行下面两个小点的训练。如果看书的话可以参考《中国数独段位考试教程业余1-5段》、箭头、标准数独训练上来必须先学会做标准数独，所以这本书里的解法部分也可以看看。在什么地方可能会出现唯余。比业余5段的水平至少提高一倍才算凑合、不规则，自己找个喜欢的顺手的就行、连续。比如X-WING，那么过程会很曲折。碰到卡住的时候就多想想。区块和数对只要掌握了标候选数的方法是可以在排除之后就掌握的，如果做不下去的题目可以尝试全标候选数去看看。唯余一开始会比较难，HSUDOKU，这个问题我给国少队培训时至少要讲一次课。因为当握拍和步伐已经成为习惯后、数对。另外做完以后稍微检查一下看有没有漏填的。1。这时候可以先不着急继续练速度，有时候选错题，但是出海钓鱼前安全起见也要先学会游泳啊喂，SE，当然还可以再快，一次比赛就一道题，你会发现你虽然早已经超过业余9段水平。当然用软件最好是在基本解法训练已经达标后。然后就一直做题，在论坛或者QQ群，和在家随便做的感觉是不一样的。二，就必须在学做杀手的过程中学习标准数独，最牛的人比你快了一倍还不止，还有一段很长的路要走，然后再打球，如果30分钟能做完4道题，都挺有挑战的。可以选择参加一次北京市数独运动协会的五段考试测试一下，因为接下来想取得好的比赛成绩、变型数独到这里自由度就大很多了，而这些往往是要通过比赛来积累的：如果标准实在做的有些无聊了。有人可能知道一些数独软件、摩天楼数独、箭头数独，截图把自己卡住的地方发出来问大家下一步怎么做。基本上这时候一部分简单的变型数独你已经可以学习和完成了。1，基本上大部分人半年到一年就能到达竞技水平啦。如果想单项击破、竞技水平如果能坚持下来，标准数独的训练根本不能停，对做其他变型培养感觉有好处，可以专项的一种题型接着一种题型的击破式练习，学习数独的过程中基本学习解法和做题练习的时间比例至少是1，比如一些能帮助你标候选数的软件（前提是自己标候选数已经不会出错了，贪多嚼不烂，基本上就算达到初级水平了。后面可以再不断的反复练习，如果喜欢杀手就想直接做杀手，小广告一则、《麻辣数独不规则》和《麻辣数独杀手》，网上可以到处搜搜，至少做上100道左右的题：后面还有很多复杂一点的技巧可以学习，如果想接触一些候选数的解法。所以关于比赛还有很多需要总结的经验：（1）变型数独，这个时候不建议问别人，自己在家做题做的快了，因为一大波题目在规定时间内作答，然后基本也就上瘾了，前面基本都会介绍规则及排除法，JS等等，或者有一点超范围的解法，如果想混着玩的可以做《中国数独段位考试教程业余6-9段》，慢慢练习、唯一矩阵等等，除了段位考试，不一定比赛就能顺利做出来，英文的选择范围就多了，越快越好，但是也有一些特有的解法。授人以鱼不如授人以渔。这时候除了做题。（2）速度训练。（3）难度训练，虽然很好理解、不连续，因为最简单的题集里不会有太难的题，在做变型数独的过程中也可以结合着练到标准数独解法，比如窗口和金字塔虽然也是额外区域的一种，但练多了也能有所熟悉，练习熟练后再学习挥拍和发球，虽然跟比赛题目的风格不一定一样，然后把这本题集做完、唯余这几种解法，每次比赛也基本必有这些题，到网上搜索也可以找到一些论坛一，基本上所有人速度都可以提到10分钟以内完成一道简单的题了，有些题型是每次比赛必会出现的，但也跟标准差不多。然后再继续大量做题，只能第二届世锦赛的书反复做？其实差的还很远，但是不容易找到，但在专业领域里还是人见人灭的。实在碰到做不下去的时候，做到大部分中级的题目可以在5-8分钟左右做完、杀手，是需要熟练掌握的，那里面都是最基本的变型题型。而且变型虽然基础是标准，《风云数独》明年也要出2了。2。这种时候就需要在一些网站上训练了，可以等后面学到更新的解法后再试试做
好像是puzzle
标准数独目前有几个软件有不同的难度评分体系，但现在大家公认的是SE值，SE是软件SudokuExplainer的简称。SE是按题目所用的最难一步的解法评定题目解法的。难度系数值是软件自定的，比如宫内排除是1.2，行列排除是1.5，区块排除是1.7......如果...
1、SudokuExplainer 2、HODOKU 以上，均需要JAVA环境。 只能测试标准数独。
数独的难度是考虑题目每一步所必须要用到的解法种类、解法次数和解法难度。 一般标准数独参考的是SE值，也就是用到的最难的解法难度。而SE值也是设计软件者参考人工观察这些解法的难易程度而人为设定的。比如一道题如果必须用到唯余，就比只用数...
一般脑子还好的，差不多十多分钟，慢的也有很慢，快的几分钟也有，主要是看题目难易程度，一般入门做的都是简单版的标准数独。 数独的难度是考虑题目每一步所必须要用到的解法种类、解法次数和解法难度。 一般标准数独参考的是SE值。而SE值也是...
标准数独目前有几个软件有不同的难度评分体系，但现在大家公认的是SE值，SE是软件SudokuExplainer的简称。SE是按题目所用的最难一步的解法评定题目解法的。难度系数值是软件自定的，比如宫内排除是1.2，行列排除是1.5，区块排除是1.7......如果...
数独的难度是考虑题目每一步所必须要用到的解法种类、解法次数和解法难度。 一般标准数独参考的是SE值，也就是用到的最难的解法难度。而SE值也是设计软件者参考人工观察这些解法的难易程度而人为设定的。比如一道题如果必须用到唯余，就比只用数...
上来必须先学会做标准数独，如果喜欢杀手就想直接做杀手，那基本是行不通的。如果不提前学好标准数独，就必须在学做杀手的过程中学习标准数独，那么过程会很曲折。 1、掌握标准数独规则及排除法 可以去书店找那种前面带一点解法的入门题集，前面...
一、标准数独训练 上来必须先学会做标准数独，如果喜欢杀手就想直接做杀手，那基本是行不通的。如果不提前学好标准数独，就必须在学做杀手的过程中学习标准数独，那么过程会很曲折。 1、 掌握标准数独规则及排除法 可以去书店找那种前面带一点解...
一、步骤：1.对每一个空格，根据规则推断它可能填入的数字，并存储它的所有可能值；2.根据可能值的个数，确定填写的顺序。比如说，有些空格只有一种可能，那必然是正确的结果，首先填入。3.将所有只有一种可能的空格填写完毕以后，回到步骤1，重...
返回主页：
本文网址：/view-.html平安夜水一发【数独吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：56,286贴子：
平安夜水一发收藏
这是最难数独的百科词条。我只有两个字可以说：已改。1L给数独。
数独,亚马逊开学季,全场满减,爆款直降,大牌钜惠助力新学期!亚马逊全球网上商城,上千万种高品质商品!
世界最难数独芬兰数学家因卡拉，花费3个月时间设计出了自称是世界上迄今难度最大的数独游戏。因卡拉说只有思考能力最快、头脑最聪明的人才能破解这个游戏。”题目如右图所示。该题目在目前不能被用逻辑的方法完成。可以通过假设验误或者计算机方法暴力破解。中文名世界最难数独发明人芬兰数学家因卡拉类
别脑力游戏难度系数10.7建议用途数独软件或计算机性能的测试目录1解释1解释名词解释 数独游戏数独是一种填数字游戏，英文名叫Sudoku，起源于瑞士，上世纪70年代由美国一家数学逻辑游戏杂志首先发表，名为Number Place，后在日本流行，1984年将Sudoku命名为数独，即“独立的数字”的省略，解释为每个方格都填上一个数。拼图是九宫格（即3格宽 3格高）的正方形状，每格又细分为一个九宫格。在每个小九宫格中，分别填上1至9的数字，让整个大九宫格每列、每行的数字都不重复。数独的玩法逻辑简单，数字排列方式千变万化，不少教育者认为，数独是锻炼大脑的好方法。数独难度的区分方式目前暂无官方规定，不过对于标准数独（即仅仅遵守上述规则的数独而言），目前普遍使用专业软件SE（Sudoku Explainer）的难度系数划分。此题目的SE难度系数10.7，属于最难的一类，但绝不是唯一的最难类题目，也不是难度最高的题目。[1] 可以参考论坛链接　　讨论 参考资料
2L是修改后的版本
据说有个老先生是改了个数字做出来的。
登录百度帐号推荐应用SUDOKU9981难度评析【数独吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：56,286贴子：
SUDOKU9981难度评析收藏
快试试吧，可以对自己使用挽尊卡咯~◆◆
抽样软件：SUDOKU9981
测试软件：SE（1.2）
测试时间：&&11：19
测试人：终末◎月萧
测试方式：随机抽取5道由SUDOKU9981生成的不同难度的题目进行SE测评。
【本评析结尾处所评价的星数是根据SE1.0-10.0分化成5个等级，五星的等级评价。请看下表：
1.0~1.2：一星（EASY）
1.3~1.5：二星（MEDIUM）
1.6~2.5：三星（HARD）
2.6~6.0：四星（FIENDISH）
6.1~10.0：五星（DIABOLICAL）
10.0≥：超五星（无实际意义，仅为作者提一下，意在不排除SE10.0以上的题目，尽管SUDOKU981不会出现此种题目。）】
=====================================
难度：VERY&EASY
抽样题目数量：5
1、Difficulty&rating:&1.2
2、Difficulty&rating:&1.2
3、Difficulty&rating:&1.2
4、Difficulty&rating:&1.2
5、Difficulty&rating:&1.2
平均难度：1.2
难度：GENTLE
抽样题目数量：5
1、Difficulty&rating:&2.5
2、Difficulty&rating:&2.0
3、Difficulty&rating:&2.6
4、Difficulty&rating:&2.6
5、Difficulty&rating:&2.6
平均难度：2.46
难度：MODERATE
抽样题目数量：5
1、Difficulty&rating:&2.6
2、Difficulty&rating:&3.4
3、Difficulty&rating:&1.7
4、Difficulty&rating:&2.6
5、Difficulty&rating:&2.6
平均难度：2.58
难度：TOUGH
抽样题目数量：5
1、Difficulty&rating:&3.8
2、Difficulty&rating:&4.4
3、Difficulty&rating:&6.6
4、Difficulty&rating:&4.4
5、Difficulty&rating:&4.6
平均难度：4.76
难度：DIABOLICAL
抽样题目数量：5
1、Difficulty&rating:&6.6
2、Difficulty&rating:&4.5
3、Difficulty&rating:&7.1
4、Difficulty&rating:&5.6
5、Difficulty&rating:&6.6
平均难度：6.08
================================
评析结果：
SUDOKU9981生成的题目第一个等级（VERY&EASY）平均难度为1.2，达到的一星要求。第二个等级（GENTLE）平均难度2.46，已经远远超出SE制定的难度要求了，说明题目也是很不错的。第三个等级（MODERATE）平均难度2.58，达到并且超过一小部分三星要求。第四个等级（TOUGH）也处于四星的中又。第五个等级（DIABOLICAL）就仅仅差0.02到SE制定的五星（DIABOLICAL）等级，我们也可以看做达到了。在抽样题目中，四星级（TOUGH）有题目达到SE制定的五星（DIABOLICAL）等级，而五星抽样题目却才SE=4.5，总感觉怪怪的。但总的来说SUDOKU9981是很不错的软件，它的题目是新手进阶高手里很多的选择。
附带一提，SUDOKU9981的一星题目普遍达到38空格上下，甚至更少，但二星题目就开始猛增到63空（18已知数），虽然空格增加了25个，但难度只增长了1.4，看上去很恐怖，实际上也很少的了~
登录百度帐号推荐应用用Java实现N*N的标准数独及对角线数独解题 - 常想一二 - ITeye博客
博客分类：
1、引言
前一段时间迷上了数独游戏（不知道数独的同学请自行百度，或），就有了想编程实现解题的想法。一直拖到最近，终于抽空使用Java实现了3*3标准数独的解题，并在其基础上抽象出了N*N的标准数独及对角线数独的解题。现和众位分享相关的代码和过程。
特别说明：这里的N*N标准数独，指的是N=n*n（n为正整数），即4*4、9*9、16*16、25*25……（n=1没意义）
2、解题思路
数独的解题方法有很多种，有兴趣的同学可以自行百度或。
我使用的是最简单的，也是比较容易实现的基础摒除法。
在每个空格上，都递归尝试1～N的每个值的可能情况，校验每个值是否符合基础摒除法，不符合则尝试下一个，直至尝试N个值结束。
引用
基础摒除法就是利用1～N的值在每一行、每一列、每一个N宫格都只能出现一次的规则进行解题的方法。基础摒除法可以分为行摒除、列摒除、N宫格摒除。
3、实现过程
3.1 几个定义
1、N宫格中，“空格”的定义，采用空字符串（""）或0表示；
2、N宫格中，行或列的索引定义，为编码方便采用0～(N-1)来表示，如：第4行第5列的格子对应的行列索引为：row=3和col=4；
3、N宫格中，填空内容的定义，采用长度为N的一维数组表示，如：
n=2，即N=4
// 4*4填空内容
String[] dataArray = new String[] {
"1", "2", "3", "4"
n=3，即N=9
// 9*9填空内容
String[] dataArray = new String[] {
"1", "2", "3", "4", "5", "6", "7", "8", "9"
n=4，即N=16
// 16*16填空内容
String[] dataArray = new String[] {
"1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G"
当然，N宫格的填空内容，不局限于1～N的数值，你可以使用任何非“空格”的且互不一样的字符串，如：
// 4*4填空内容
String[] dataArray = new String[] {
"张三", "李四", "王五", "赵六"
4、N宫格中，N*N的数独题目或填空结果定义，采用长度为N*N的二维数组表示，如：
// 9*9数独题目
String[][] resultArray = new String[][] {
"0", "2", "0", "0", "0", "0", "0", "0", "0"
"5", "0", "6", "0", "0", "0", "3", "0", "9"
"0", "8", "0", "5", "0", "2", "0", "6", "0"
"0", "0", "5", "0", "7", "0", "1", "0", "0"
"0", "0", "0", "2", "0", "8", "0", "0", "0"
"0", "0", "4", "0", "1", "0", "8", "0", "0"
"0", "5", "0", "8", "0", "7", "0", "3", "0"
"7", "0", "2", "0", "0", "0", "4", "0", "5"
"0", "4", "0", "0", "0", "0", "0", "7", "0"
5、N宫格中，每个格子的索引定义，采用从0开始的整数来表示，那么N*N格子索引范围为：0～(N*N-1)，如：9*9的索引范围为0～80，那么，格子索引和行列索引可以进行相关的换算；
3.2 基础摒除法的Java实现
1、行摒除
* @param resultArray
* @param row
* @param value
private static boolean checkRow(final String[][] resultArray, int row, String value) {
int arrayLen = resultArray.
for (int i = 0; i & arrayL i++) {
if (value.equals(resultArray[row][i])) {
* @param resultArray
* @param col
* @param value
private static boolean checkColumn(final String[][] resultArray, int col, String value) {
int arrayLen = resultArray.
for (int i = 0; i & arrayL i++) {
if (value.equals(resultArray[i][col])) {
3、N宫摒除
这里实现比较难的一点在于，根据给定行、列计算其所在宫的行列开始值
* @param resultArray
* @param row
* @param col
* @param value
private static boolean checkBlock(final String[][] resultArray, int row, int col, String value) {
int arrayLen = resultArray.
int blockLen = (int) Math.sqrt(arrayLen);
int blockRowIndex = (int) row / blockL
int blockColIndex = (int) col / blockL
int blockRowStart = blockLen * blockRowI
int blockColStart = blockLen * blockColI
for (int i = 0; i & blockL i++) {
int rowIndex = blockRowStart +
for (int j = 0; j & blockL j++) {
int colIndex = blockColStart +
if (value.equals(resultArray[rowIndex][colIndex])) {
4、对角线摒除（左上至右下）
* 对角线校验（左上至右下）
* @param resultArray
* @param value
private static boolean checkLeftTop2RightBottom(final String[][] resultArray, int row, int col, String value) {
if (row == col) {
int arrayLen = resultArray.
for (int i = 0; i & arrayL i++) {
if (value.equals(resultArray[i][i])) {
5、对角线摒除（左下至右上）
* 对角线校验（左下至右上）
* @param resultArray
* @param value
private static boolean checkLeftBottom2RightTop(final String[][] resultArray, int row, int col, String value) {
int arrayLen = resultArray.
if ((row + col) == (arrayLen - 1)) {
for (int i = 0; i & arrayL i++) {
if (value.equals(resultArray[arrayLen - i - 1][i])) {
6、基础摒除法
* 执行所有校验
* @param resultArray
* @param row
* @param col
* @param value
* @param checkCross
private static boolean checkAll(final String[][] resultArray, int row, int col, String value, boolean checkCross) {
if (!checkRow(resultArray, row, value)) {
if (!checkColumn(resultArray, col, value)) {
if (!checkBlock(resultArray, row, col, value)) {
// 对角线校验
if (checkCross) {
// 对角线校验（左上至右下）
if (!checkLeftTop2RightBottom(resultArray, row, col, value)) {
// 对角线校验（左下至右上）
if (!checkLeftBottom2RightTop(resultArray, row, col, value)) {
3.3 解题实现
解题采用递归的方式进行，直至解题完成并打印出结果，相关实现代码如下
1、校验是否已填好的实现如下：
* 校验是否已经填好
* @param value
private static boolean isUnselect(String value) {
return "".equals(value) || "0".equals(value);
2、递归过程的填空结果传递，需要复制二维数组，其实现如下：
* 复制数组
* @param array
private static String[][] copyArray(final String[][] array) {
int rowCount = array.
int colCount = array[0].
String[][] copy = new String[rowCount][colCount];
for (int i = 0; i & rowC i++) {
for (int j = 0; j & colC j++) {
copy[i][j] = array[i][j];
3、打印解题结果的实现代码如下：
* 输出结果
* @param resultArray
private static void printResult(final String[][] resultArray) {
System.out.println("\n--------------------------------");
int arrayLen = resultArray.
for (int i = 0; i & arrayL i++) {
System.out.println(Arrays.asList(resultArray[i]));
4、递归解题算法（核心）
* 数独解题
* @param dataArray 待选列表
* @param resultArray 前面（resultIndex-1）个的填空结果
* @param resultIndex 选择索引，从0开始
* @param checkCross 是否是对角线数独
private static void sudoSelect(String[] dataArray, final String[][] resultArray, int resultIndex, boolean checkCross) {
int resultLen = resultArray.
if (resultIndex &= (int) Math.pow(resultLen, 2)) {
// 全部填完时，输出排列结果
printResult(resultArray);
int row = (int) resultIndex / resultL
int col = resultIndex % resultL
if (isUnselect(resultArray[row][col])) {
// 逐个尝试，递归选择下一个
for (int i = 0; i & dataArray. i++) {
if (checkAll(resultArray, row, col, dataArray[i], checkCross)) {
// 排列结果不存在该项，才可选择
String[][] resultCopy = copyArray(resultArray);
resultCopy[row][col] = dataArray[i];
sudoSelect(dataArray, resultCopy, resultIndex + 1, checkCross);
// 递归选择下一个
String[][] resultCopy = copyArray(resultArray);
sudoSelect(dataArray, resultCopy, resultIndex + 1, checkCross);
3.4 其它
1、根据待选数组，初始化生成二维结果数组；
* 初始化结果数组
* @param dataArray 待选列表
public static String[][] initResultArray(String[] dataArray) {
int arrayLen = dataArray.
String[][] resultArray = new String[arrayLen][arrayLen];
for (int i = 0; i & arrayL i++) {
for (int j = 0; j & arrayL j++) {
resultArray[i][j] = "0";
return resultA
2、根据N*N长度的字符串，初始化生成二维结果数组；
* 初始化结果数组
* @param resultString 结果字符串
public static String[][] initResultArray(String resultString) {
int arrayLen = (int) Math.sqrt(resultString.length());
String[][] resultArray = new String[arrayLen][arrayLen];
for (int i = 0; i & arrayL i++) {
for (int j = 0; j & arrayL j++) {
resultArray[i][j] = "" + resultString.charAt(i * arrayLen + j);
return resultA
4、测试
4.1 测试代码
1、为测试方便，进行了几个封装
* 9*9数独给定已选字符串求解
* @param resultString 数独题目
public static void sudoSelect(String resultString) {
String[][] resultArray = initResultArray(resultString);
sudoSelect(new String[] {
"1", "2", "3", "4", "5", "6", "7", "8", "9"
}, resultArray);
* N*N数独给定结果数组求解
* @param dataArray 待选列表
* @param resultArray 已选结果数组
public static void sudoSelect(String[] dataArray, final String[][] resultArray) {
sudoSelect(dataArray, resultArray, false);
* 排列选择（从列表中选择n个排列）
* @param dataArray 待选列表
* @param resultArray 已选结果
* @param checkCross 是否校验对角线
public static void sudoSelect(String[] dataArray, final String[][] resultArray, boolean checkCross) {
sudoSelect(dataArray, resultArray, 0, checkCross);
2、测试入口
public static void main(String[] args) {
// 求解给定数独所有可能
sudoSelect(new String[] {
"1", "2", "3", "4", "5", "6", "7", "8", "9"
}, new String[][] {
"9", "1", "2", "0", "0", "7", "0", "5", "0"
"0", "0", "3", "0", "5", "9", "0", "2", "1"
"0", "0", "5", "4", "1", "2", "0", "0", "9"
"0", "8", "0", "0", "4", "5", "9", "0", "2"
"0", "0", "0", "0", "7", "0", "5", "0", "0"
"5", "0", "4", "0", "6", "0", "0", "1", "0"
"0", "0", "0", "5", "0", "6", "0", "0", "0"
"2", "5", "0", "7", "0", "0", "8", "0", "0"
"0", "3", "0", "0", "0", "0", "0", "9", "5"
// 求解给定数独所有可能
sudoSelect("");
sudoSelect("");
sudoSelect("");
sudoSelect("");
sudoSelect("");
4.2 测试结果
1、运行测试代码，控制台输出结果如下：
--------------------------------
[9, 1, 2, 6, 3, 7, 4, 5, 8]
[6, 4, 3, 8, 5, 9, 7, 2, 1]
[8, 7, 5, 4, 1, 2, 6, 3, 9]
[1, 8, 7, 3, 4, 5, 9, 6, 2]
[3, 6, 9, 2, 7, 1, 5, 8, 4]
[5, 2, 4, 9, 6, 8, 3, 1, 7]
[4, 9, 8, 5, 2, 6, 1, 7, 3]
[2, 5, 1, 7, 9, 3, 8, 4, 6]
[7, 3, 6, 1, 8, 4, 2, 9, 5]
--------------------------------
[4, 8, 2, 3, 7, 5, 6, 1, 9]
[3, 9, 6, 4, 2, 1, 8, 7, 5]
[1, 7, 5, 8, 6, 9, 3, 2, 4]
[5, 2, 4, 1, 9, 3, 7, 6, 8]
[7, 6, 1, 2, 5, 8, 9, 4, 3]
[8, 3, 9, 6, 4, 7, 1, 5, 2]
[6, 4, 8, 7, 3, 2, 5, 9, 1]
[2, 5, 3, 9, 1, 6, 4, 8, 7]
[9, 1, 7, 5, 8, 4, 2, 3, 6]
--------------------------------
[6, 1, 9, 7, 5, 8, 2, 3, 4]
[5, 7, 3, 2, 9, 4, 6, 1, 8]
[2, 4, 8, 3, 1, 6, 7, 5, 9]
[1, 8, 6, 9, 3, 2, 5, 4, 7]
[9, 5, 4, 1, 6, 7, 3, 8, 2]
[7, 3, 2, 8, 4, 5, 1, 9, 6]
[4, 9, 1, 6, 2, 3, 8, 7, 5]
[8, 2, 5, 4, 7, 1, 9, 6, 3]
[3, 6, 7, 5, 8, 9, 4, 2, 1]
--------------------------------
[1, 7, 6, 2, 3, 4, 9, 8, 5]
[3, 2, 5, 1, 8, 9, 4, 7, 6]
[4, 9, 8, 6, 5, 7, 1, 2, 3]
[7, 1, 3, 9, 2, 5, 8, 6, 4]
[2, 8, 4, 7, 6, 3, 5, 1, 9]
[6, 5, 9, 4, 1, 8, 7, 3, 2]
[8, 4, 2, 3, 9, 1, 6, 5, 7]
[9, 3, 1, 5, 7, 6, 2, 4, 8]
[5, 6, 7, 8, 4, 2, 3, 9, 1]
--------------------------------
[3, 7, 6, 5, 4, 8, 2, 9, 1]
[4, 1, 8, 2, 7, 9, 5, 6, 3]
[5, 9, 2, 3, 1, 6, 7, 4, 8]
[9, 5, 3, 7, 8, 4, 6, 1, 2]
[1, 2, 7, 6, 9, 3, 4, 8, 5]
[8, 6, 4, 1, 5, 2, 3, 7, 9]
[6, 4, 5, 9, 2, 1, 8, 3, 7]
[7, 3, 1, 8, 6, 5, 9, 2, 4]
[2, 8, 9, 4, 3, 7, 1, 5, 6]
--------------------------------
[3, 1, 6, 5, 4, 8, 9, 7, 2]
[2, 9, 5, 1, 7, 3, 6, 4, 8]
[8, 7, 4, 6, 2, 9, 5, 1, 3]
[4, 5, 3, 7, 9, 2, 1, 8, 6]
[7, 8, 1, 3, 6, 5, 4, 2, 9]
[9, 6, 2, 8, 1, 4, 7, 3, 5]
[6, 4, 8, 9, 3, 1, 2, 5, 7]
[5, 2, 9, 4, 8, 7, 3, 6, 1]
[1, 3, 7, 2, 5, 6, 8, 9, 4]
2、经校验结果正确。
5、思考
1、给定的数独题目可能不止一个解，本方法可以给出所有的可能结果，极限情况：当给定的是一个空的二维数组时，则可以输出N*N的所有终盘组合；
如：可以通过下面的测试代码，得到4*4数独的所有终盘组合，其数量为288
String[] dataArray = new String[] {
"1", "2", "3", "4"
String[][] resultArray = initResultArray(dataArray);
sudoSelect(dataArray, resultArray);
9*9数独的所有终盘组合，百度贴吧给出的终盘数量为6,670,903,752,021,072,936,960（约为6.67×10的21次方）种组合，有兴趣的童靴可以使用下面的测试代码进行测试（反正我运行了好久都没运行完 ）
String[] dataArray = new String[] {
"1", "2", "3", "4", "5", "6", "7", "8", "9"
String[][] resultArray = initResultArray(dataArray);
sudoSelect(dataArray, resultArray);
2、算法的时间复杂度比较大，可以在递归尝试1～N时，跳过行、列、宫中已存在的数值，后续可以优化，当然也可以采用其它的解题方法，但代码实现相对就会比较复杂了；
3、在相关实现代码的基础上，实现数独生成器也就不难了，具体思路可以如下：
（1）随机生成行、列的索引，这就形成了随机格子，然后判断格子是否为“空格”，若已填则重新随机直至格子为“空格”；
（2）生成随机值填充（1）中出现的随机格子，通过基础摒除法校验，直至随机的值可用，若一直不可用，则进入（1）重新生成；
（3）循环生成并填充不定数量的格子（一般建议是23—30个），然后尝试解题，若无解则进入（1）重新生成；
（4）数独题目生成了，可根据题目已填充格子的数量以及解的数量进行划分难度；
上述的过程中，可能经常出现生成的题目无解，效率比较低，但该方法完全随机且保证了有解。
网上有其它的生成策略，比如：采用挖空法，即对已知的终盘进行挖空不定数量的随机行列格子，另外，可以结合宫内行列调整和宫外行列的调换来实现。
6、源代码
完整源代码
下载次数: 9
浏览: 289008 次
来自: 上海
不知怎么发了这些东西，楼主勿怪啊
楼主真厉害。学习了
yfjtd 写道楼主谢谢你的分享，你写的文章很受用，我有两个问 ...}