1）当我们得到一个主题时，首先，我们将根据我们已知的条件对数据进行初步分析和分析。

相当于填写9家所有的不确定性，加里和标记选项。

refreshstat（）函数

2）从那时起，思维将进入猜测/验证的循环。

在9宫，有可能尝试验证现有条件是否被侵犯的可能选项。

每一个新的分支，最终的结果都不超过两个，答案/错误。
复制代码代码如下所示：
当（真）{
创建一个setone（）；
var b = refreshstat（）；
（如果！一个| | B）{ / /如果= =虚假或B = =真的，你可以跳出循环
打破；
}
}

人脑思维的实际过程是用较少的选项遍历分支。

因此，程序实现也是确定点 2叉分支/ 3叉/的关键…

3）当所有的路径被搜索时，答案不是唯一的例子，它违背了数独游戏的宗旨。

下面的部分是所有代码，便于阅读，不删除调试信息。

复制代码代码如下所示：


数独解题程序


功能keygo（EVT，obj）{
关键=窗口。eventevt。关键词：evt.which；
VaR下= obj.tabindex；
无功输入= document.getelementsbytagname（输入）；
如果（关键= = 38）{ / /↑
如果（下一个- 9 > = 0）{
输入{ next-9 }选择（）。
}
}
如果（键= 40）{ / /：
如果（下+ 9 < 81）{
输入{下一个+ 9 }。选择（）
}
}
如果（键= 37）{…
如果（下一个- 1 > = 0）{
输入{ next-1 }选择（）。
}
}
如果（键= 39），{
如果（下一+ 1 < 81）输入{ Next + 1 }，选择（）；
}
}





004502006
00000000 5
002014007
008000012
070080050
九亿三千零二万零七百
六亿零一十九万零二百
020000000
三亿零二十万八千五百
您可以将文本复制到较低的框中，从左到右粘贴81个数字序列，从上到下，而不是0，中间的非数字字符将被忽略。


无功maxrow = 9；
MAXCOL var = 9；
无功strtbody = {}；
对于（var i = 0；i < maxrow；i++）{
StrTbody.push（）；
对于（var j = 0；J < MAXCOL；j++）{
StrTbody.push（< TD风格= 'border-left：+（J % 3 = = 01:0）
+ PX黑色固体；边框右：+（J % 3 = = 21:0）
+ PX黑色固体；边境上：+（我% 3 = = 01:0）
+ PX黑色固体；底部边框：+（我% 3 = = 21:0）+PX黑色固体；> <输入风格= 'width：20px；TabIndex =+（我* 9 + J）
+ 'onclick =‘选中（本）；onkeyup =返回keygo（事件，这类型的ID = =）中输入+（我* 9 + J）+'name = n +（我* 9 + J）+价值=>））
}
StrTbody.push（）；
}
StrTbody.push（）；
无功stbody = {}；
对于（var i = 0；i < maxrow；i++）{
STbody.push（）；
对于（var j = 0；J < MAXCOL；j++）{
STbody.push（< TD风格= 'border-left：+（J % 3 = = 01:0）
+ PX黑色固体；边框右：+（J % 3 = = 21:0）
+ PX黑色固体；边境上：+（我% 3 = = 01:0）
PX +实体+黑色；底部边框：（我% 3 = = 21:0）+ PX黑色固体；>）；
}
STbody.push（）；
}
STbody.push（）；
var obj = document.getelementbyid（sodukutable ）；
obj.innerhtml = strtbody.join（）；
var obj2 = document.getelementbyid（statusdiv ）；
var网格{
{ 5, 7, 0，1, 2, 0，0, 0, 0 }，
{ 0, 0, 0，0, 0, 0，0, 0, 0 }，
{ 0, 0, 6，7, 0, 0，0, 8, 0 }，
{ 3, 0, 4，0, 0, 9，0, 7, 0 }，
{ 0, 2, 0，0, 7, 0，0, 5, 0 }，
{ 0, 1, 0，3, 0, 0，9, 0, 2 }，
{ 0, 8, 0，0, 0, 2，1, 0, 0 }，
{ 0, 0, 0，0, 0, 0，0, 0, 0 }，
{ 0, 0, 0，0, 5, 4，0, 6, 3 } }；
无功candidatnum = { }；
var列= }；
var行= }；
var块= { }；
var文件= 0；
var丢弃= 0；
var成功= false；
新数组（）；
VaR LOG1 = document.getelementbyid（statusdiv ）；

功能步骤（电流1，阵列）{
这temp1 =新的数组（）；
这一步= {数组{ 0 }，{ 1 }数组，数组{ 2 } }；
对于（var i = 0；i < 9；i + +）
{
这个temp1 {我} =新的数组（）；
对于（var j＝0；j＜9；j + +）
{
这个temp1 {我} { } = {我}，{，}电流1；
}
}
}
输出（网格）；
init（）；

功能推送（电流1，I，J，N）{
var =新的台阶（电流1，{我，J，N }）；
Steps.push（S）；
}
函数POP（）{
步骤= steps.pop（）；
丢弃+ +；
网格= step.temp1；
网格{步骤{步骤0 { } }步骤.步骤{ 1 } } =步骤.步骤{ 2 }；
VaR的时间= document.getelementbyid（'paperlist）；
timeline.value（'discard：= { + + }：{丢弃+论文+} '）；
timeline.scrolltop = timeline.scrollheight；
返回步；
}

功能检查（obj）{
如果（obj值= = 0）返回；
对于（var i = 0；i < 9；i + +）{
对于（var j＝0；j＜9；j + +）{
var text = document.getelementbyid（输入+（我* 9 + J））；
如果（文本。值= = obj值）{
样式。背景=绿色；
其他{ }
文本。样式。背景；
}
}

}

}
功能checknuminput（数组num，x，y）{
/目标：
检查数组的参数：矩阵号：x冲突检测值：位置检测
这座宫殿没有冲突/等级，回归真实；
返回false 发现冲突；
（（如果行{ }（Num < 1）= 0）（列{ }）（Num < 1）= 0）
（块{ parseInt（X / 3）* 3 + parseInt（Y / 3）}（Num＜1））= = 0）{
返回true；
}
返回false；
}

函数（数组）{
var结果=真；
对于（var i = 0；i < 9；i + +）
{
对于（var j＝0；j＜9；j + +）
{
document.getelementbyid（输入+（我* 9 + J））。价值= {我} { }阵列{J}.；
如果（数组{ = } = 0）结果= false；
}
}
返回结果；
}
功能setone（）{
var = false；
/目标：
遍历矩阵，可以简单地刷新当前，或者已经在错误中找到。
对于（var i = 0；i < 9；i + +）{
对于（var j＝0；j＜9；j + +）{
/目标：
（candidatnum {我} {，} { 0 } { } {我 /网格J } = = 0 = = 0），没有候选人号码是错的
/ /（candidatnum {我} {，} { 0 } = = 1），唯一候选数
/ / checknuminput（网格，candidatnum {我} {，} { 10 }，I，J），检查逻辑数
没有候选人数量| | / /判断最后的候选人不符合条件的数字逻辑，从这里返回或返回一个错误
如果（{我} { }网格J = = 0 candidatnum {我} {，} { 0 } = = 0 | |
（candidatnum {我} {，} { 0 } = = 1！checknuminput（网格，candidatnum {我} {，} { 10 }，i，j）））{
如果（网格{ = } = 0）{
结果=假；
}
如果（步骤长度> 0）{后退/后退
（POP）；标签已显示为逻辑错误，浪费。
返回true；
{人}
如果（！成功）{
警报（）堆栈的结尾！；主题错误，结束
}
返回false；
}
}
如果（candidatnum {我} {，} { 0 } = = 1）{ / /唯一的选择
{我} { }网格J = candidatnum {我} {，} { 10 }； / /更新矩阵
refreshstat3（candidatnum {我} {，} { 10 }，I，J）； / /更新宫殿的行列
candidatnum {我} {，} { 0 } = 0； / /标记选择
结果=真；
继续；
}

}
}
如果（结果= = false）{ / /（candidatnum {我} {，} { 0 }！= 1）情况、筛选
返回选择（）；
}
返回结果；
}
功能refreshstat3（num，x，y）{ / /更新宫殿的行列
行{X}的<<民| = 1；
列{ Y } 1 <<民| =；
块{ parseInt（X / 3）* 3 + parseInt（Y / 3）} 1 | = <民；

}
/ *********************
*矩阵数据分析
*统计盈余选项
********************* /
功能refreshstat（）{
var =真的；
/目标：
分解行/列/房子
对于（var i = 0；i < 9；i + +）{
行{ } = 0； /行
列{ } = 0； /列
块{我} = 0； / /房子
对于（var j＝0；j＜9；j + +）{
如果（网格{ } }！= 0）{
网格{我} { } { }，1行| =；
{人}
行{ = }（1 < <网格{ } }）；
}
如果（网格{ } }，}！= 0）{
{ } {我{J}.电网} 1列{我} | =；
{人}
列{ i }（1）；
}
如果（网格{ parseInt（我 / 3）* 3 + parseInt（J / 3）} {我% 3 * 3 + 2 % 3 }！= 0）{
块{我} | = 1 <网格{ parseInt（我 / 3）* 3 + parseInt（J / 3）* 3 + 3 } { 3 }，我% %；
}
}
}
/目标：
/ /遍历矩阵，候选标记candidatnum {我} {，} { 0 }
/ / candidatnum {我} {，} { 0 } = 0；确定存在的价值
/ / candidatnum {我} {，} { 0 } = k，可能值的数量；
可选的数字candidatnum {我} {，} { 1 } = 987654321x / / 2进制数字表示
对于（var i = 0；i < 9；i + +）{
对于（var j＝0；j＜9；j + +）{
如果（网格{ } }！= 0）{
candidatnum {我} {，} { 0 } = 0；
继续；
}
var大小= 0；
以上=假；
对于（var = 1；k＜10；k + +）{
如果（checknuminput（网格，K，I，J））{
K 1 candidatnum {我} {，} { 1 } | =；
candidatnum {我} {，} { 10 } = K；
以上=假；
大小+；
{人}
candidatnum {我} {，} { 1 } = ~（1 << K）；
}
}
candidatnum {我} {，} { 0 } = / /标志尺寸；剩下的一些选项
}
}
回报；
}

函数（计算）入口函数
读取数据
var开始=新日期（）；
对于（var i = 0；i < 9；i + +）
{
对于（var j＝0；j＜9；j + +）
{
var text = document.getelementbyid（输入+（我* 9 + J））；
{我} { }网格J = parseInt（文本的价值。）；
}
}

刷新/网格
RefreshStat（）；
输出（网格）；
矩阵计算
当（真）{
创建一个setone（）；
var b = refreshstat（）；
（如果！一个| | B）{ / /如果= =虚假或B = =真的，你可以跳出循环
打破；
}
}
输出（网格）
警报（时间+（New Date（）-开始）+MS）；
成功=真实；
计算结束

唯一的答案是验证
如果（论文）！=丢弃）{
如果（步骤长度> 0）{后退/后退
（POP）；当前标签浪费
矩阵计算
当（真）{
创建一个setone（）；
var b = refreshstat（）；
（如果！一个| | B）{ / /如果= =虚假或B = =真的，你可以跳出循环
打破；
}
}
如果（b）{
警报（）答案不是唯一的！记录uff01 ）；
输出（网格）
}
{其他
警惕（唯一的答案！！！）；唯一的答案
}
{人}
警惕（）错误的结束！；
返回false；
}
}
}
功能cleargrid（）{
对于（var i = 0；i < 9；i + +）{
对于（var j＝0；j＜9；j + +）{
网格{ } = 0；
document.getelementbyid（输入+（我* 9 + J））。价值= { } { }电网{J}.；
}
}
输出（网格）；
}
函数init（）{
对于（var i = 0；i < 9；i + +）
{ candidatnum {我} =新的数组（）；

对于（var j＝0；j＜9；j + +）
{ } { } {我candidatnum J =新的数组（）；

对于（k＝0；k＜11；k +）
{ } { } {我candidatnum j { } = 0 K；
}
}
}
}
函数选择（）{
/目标：
遍历矩阵，从分支电流位置搜索的建立。
无功binarynode = false；
对于（var i = 0；i < 9；i + +）{
对于（var j＝0；j＜9；j + +）{
2叉树分支：
如果在一个位置有两个可能的选项，2个1个选项
假定为选项1，并根据2选项在同一时间生成一个新标签进行检查。
如果（candidatnum {我} {，} { 0 } = 2）{ / /有2种选择
binarynode =真；
var = 1；
对于（var = 1；k＜10；k + +）{
如果（（candidatnum {我} {，} { 1 }（10）{）
如果（发现> 0）{
论文+；
VaR的时间= document.getelementbyid（'paperlist）；
timeline.value（论文：+论文+：+我+ = 'add + J ++ +'）；
timeline.scrolltop = timeline.scrollheight；
推（网格，i，j，k）；
其他{ }
发现= k；
}
}
}
网格{ } } =找到；
candidatnum {我} {，} { 0 } = 0； / /马克在当前标签选择
VaR的时间= document.getelementbyid（'paperlist）；
timeline.value（'try =电流：' +我+的+ J ++发现+ '）；
timeline.scrolltop = timeline.scrollheight；
返回true；
}
}
}
如果（！Binarynode）{
VaR的时间= document.getelementbyid（'paperlist）；
timeline.value =（2叉支没找到！；
timeline.scrolltop = timeline.scrollheight；
对于（var i = 0；i < 9；i + +）{
对于（var j＝0；j＜9；j + +）{
2个二进制树搜索失败，启动3叉树分支，如扩展，也可以启动3叉树分支：
如果在位置上有三种可能的选项，则为1 选项2 /选项3
假定为选项1，并根据2选项在同一时间生成一个新标签进行检查。
如果（candidatnum {我} {，} { 0 } = 3）{ / /有3种选择
VaR的时间= document.getelementbyid（'paperlist）；
（timeline.value + =发现3叉分枝'！）；
timeline.scrolltop = timeline.scrollheight；
binarynode =真；
var = 1；
对于（var = 1；k＜10；k + +）{
如果（（candidatnum {我} {，} { 1 }（10）{）
如果（发现> 0）{
论文+；
VaR的时间= document.getelementbyid（'paperlist）；
timeline.value（论文：+论文+：+我+ = 'add + J ++ +'）；
timeline.scrolltop = timeline.scrollheight；
推（网格，i，j，k）；
其他{ }
发现= k；
}
}
}
网格{ } } =找到；
candidatnum {我} {，} { 0 } = 0； / /马克在当前标签选择
VaR的时间= document.getelementbyid（'paperlist）；
timeline.value（'try =电流：' +我+的+ J ++发现+ '）；
timeline.scrolltop = timeline.scrollheight；
返回true；
}
}
}
}
返回false；
}
函数粘贴（）{
无功gridstr = document.getelementbyid（gtxt ）的价值；
创建一个gridstr.replace（ / /克} { ^ 0-9，）；
如果（a.length！= 81）{
警报（）数据格式不正确：+ gridstr）；
返回；
}
对于（var i = 0；i < 9；i + +）
{
对于（var j＝0；j＜9；j + +）{
{我} { }网格J = a.charat（我* 9 + J）；
document.getelementbyid（输入+（我* 9 + J））。价值= { } { }电网{J}.；
}
}
输出（网格）；
论文= 0；
丢弃= 0；
成功=假；
步骤=新数组（）；
}

这是建议，IE浏览器的使用，和调试模式打开F12