用javaｓｃｒｉｐｔ解决八皇后问题的方法综述

八皇后问题的Javaｓｃｒｉｐｔ解决方案总是觉得有必要学习这个算法，当它被使用时，它不会感到尴尬找到它。

背景

八皇后问题是一个下棋的背景：我们怎么能在8×8棋盘上放置八个皇后，这样就没有女王可以直接吃掉其他皇后为了达到这个目的，任何两个皇后不在同一个水平、垂直或对角线上。

八皇后问题可以推广到更一般的n皇后布局问题：棋盘的大小被更改为n x n，而昆斯的数目也变成n，如果且仅当n＝1或n＝4有解。

盲目的枚举算法

通过n个循环，枚举约束解（八个循环码在这里很多，四个周期），找到所有可能的位置的四个皇后，然后在整个板子上判断四个皇后是否会直接吃掉对方，这个想法是比较简单的程序。
功能会员（ARR，n）{
对于（var i = 0；i <；n；i + +）{
对于（var j = i + 1；j < n；j + +）{
如果（（ARR {我} = = ARR { J }）| | math.abs（ARR { } { } - ARR J）-我= = J）{
返回false；
}
}
}
返回true；
}
功能Queen1（）{
var arr = { }；

对于（ARR { 0 } = 1；ARR { 0 }＜4；ARR { 0 } + +）{
对于（ARR { 1 } = 1；ARR { 1 }＜4；ARR { 1 } + +）{
对于（ARR { 2 } = 1；ARR { 2 }＜4；ARR { 2 } + +）{
对于（ARR { 3 } = 1；ARR { 3 }＜4；ARR { 3 } + +）{
如果（！会员（ARR，4））{
继续；
{人}
console.log（ARR）；
}
}
}
}
}
}

Queen1（）；
{ { 2, 4, 1，3 }
{ { 3, 1, 4，2 }

作为结果，在4×4的棋盘，四个皇后不能在一排，ARR { 0 }到ARR { 3 }对应四皇后分别与数组的下标，下标对应的值是在棋盘上皇后的位置。

回溯

不要通过，转身
功能check2（ARR，n）{
对于（var i = 0；i = n - 1；i + +）{
如果（（Math.abs（ARR {我} - ARR { }）= n i）| |（ARR {我} = = ARR { }）{）
返回false；
}
}
返回true；
}

功能Queen2（）{
var arr = { }；

对于（ARR { 0 } = 1；ARR { 0 }＜4；ARR { 0 } + +）{
对于（ARR { 1 } = 1；ARR { 1 }＜4；ARR { 1 } + +）{
如果（！check2（ARR，1）继续）； / /冲突前两的女王
对于（ARR { 2 } = 1；ARR { 2 }＜4；ARR { 2 } + +）{
如果（！check2（ARR，2）继续）； / /冲突三女王之前
对于（ARR { 3 } = 1；ARR { 3 }＜4；ARR { 3 } + +）{
如果（！check2（ARR，3））{
继续；
{人}
console.log（ARR）；
}
}
}
}
}
}

Queen2（）；
{ { 2, 4, 1，3 }
{ { 3, 1, 4，2 }

非递归回溯法

算法框架：
当（k > 0 路径和没有达到目标）{ 0条道路
如果（k）搜索到叶节点
搜索到一个解决方案，输出
{人}
第一个可能的值
当（}不满足约束条件和搜索空间）{
一个可能的值
}
如果（搜索空间）{
标记/资源
1；
{人}
清理的状态空间/
1；
}
}
}
具体代码如下。最外层包含两部分。一个是遍历当前皇后的可能值。另一种是决定是否进入下一个级别或返回到以前的级别。
功能回溯（N）{
var arr = { }；

var = 1；
ARR { 0 } = 1；

当（k＞0）{

ARR { } = { K-1 K-1 ARR } + 1；
而（（ARR { } n（k-1）！check2（ARR，k-1）））{
ARR { } = { K-1 K-1 ARR } + 1；
}
女王的约束得到满足，下一步的判断

如果（ARR { K-1 } n）{
如果皇后的话
console.log（ARR）；
{人}
K + K 1；下一个皇后
ARR { } = 0 K-1；
}
{人}
K = 1；
}
}
}

回溯（4）；
{ { 2, 4, 1，3 }
{ { 3, 1, 4，2 }

递归回溯

递归调用大大减少了代码量，提高了程序的可读性。
var { } = ARR，n = 4；
函数回溯（k）{
如果（k = n）{
console.log（ARR）；
{人}
对于（var i = 1；i <；n；i + +）{
ARR { K-1 } =我；
如果（check2（ARR，k-1））{
回溯（k + 1）；
}
}
}
}

回溯（1）；
{ { 2, 4, 1，3 }
{ { 3, 1, 4，2 }

一个自大的AMB

AMB是干什么的为了给它一个数据列表，它可以返回一个满足约束条件的方法。如果它失败了，它会失败，当然，它可以返回到所有成功的案例。这很有趣。让我们看看它是如何工作的。

首先处理一个小问题，查找相邻字符串：得到字符串数组，每个数组用一个字符串，字符串的第一个字符前后字符串相同的字符，以满足这个新组的输出条件被取出的字符串。
AmbRun（功能（AMB，失败）{

约束方法
函数链接（S1，S2）{
返回s1.slice（- 1）=（0, 1）s2.slice；
}

注入数据表
VaR W1 = AMB（{
VaR W2 = AMB（{青蛙
VaR W3 = AMB（{走
VaR W4 = AMB（{ 慢

/程序
如果（！（！（（W1、W2）与（W2、W3）与联系（W3，W4）））（）失败；

console.log（{ W1 W2，W3，W4，}。加入（'））；
东西生长得很慢
}）；

看起来超级简单！但前提是你不在乎表演，那真是浪费时间！

下面是它的Javaｓｃｒｉｐｔ实现，并有兴趣研究它是如何绘制回溯的。
功能ambrun（功能）{
var选择{ }；
VaR指标；

函数（值）{
如果（values.length = = 0）{
失败（）；
}
如果（索引=选择=长度）{
Choices.push（{我：0，
计数：值，长度}；
}
var选择=选择{索引+ }；
返回值{选择}；
}

函数失败（）{抛出失败；}

当（真）{
{试
索引= 0；
返回函数（磁力轴承，失败）；
} catch（e）{
如果（e）！=失败）{
把E；
}
变量的选择；

而（（选择）= choices.pop（+ +的选择。我）= =选择。计数）{ }
如果（选择=未定义）{
返回未定义；
}
Choices.push（选择）；
}
}
}

并给出了用电磁轴承实现的八皇后问题的具体代码。
AmbRun（功能（AMB，失败）{
var = 4；
var arr = { }；
var = { }；
对于（var n＝0；n < n；n + +）{
转弯{长度= } + 1；
}
而（n）{
ARR { } = arr.length AMB（转）；
}
对于（var i = 0；i <；+；+ i）{
对于（var j = i + 1；j n；+ + j）{
创建一个数组{我}，{ } B = ARR {J}.；
如果（a = b | | math.abs（A - B）= J I）（失败）；
}
}
console.log（ARR）；
失败（）；
}）；
八皇后问题的javaｓｃｒｉｐｔ解决方案

这是八皇后问题的Javaｓｃｒｉｐｔ解决方案。整个过程不使用for循环，它是通过返回来实现的。它充分利用了地图，减少、滤波器、阵列对象连接和切片方法。
严格使用；
VaR皇后=功能（boardersize）{
使用递归生成一个开始到结束数组
var =函数（开始，结束）{
如果（开始>结束）{返回}；
回程时间（开始，结束- 1），Concat（结束）；
}；
检查组合是否有效
VaR的有效性=功能（queencol）{
检查两个冲突的位置
VaR是安全=功能（点，pointb）{
VaR的斜率=（pointa.row - pointb。行）/（pointa.col - pointb。西）；
如果（（斜率= 0）| |（斜率= 1）| |（- 1 =坡）{ return false }）；
返回true；
}；
VaR len = queencol.length；
无功pointtocompare = { {
行：queencol { 1 } Len，
Col：莱恩
}；
除了第一列之外的第一个切片数组，然后测试每个列并检测是否存在冲突，最后结合测试结果
返回queencol
切片（0，镜头- 1）
映射（函数（行，索引）{）
回报是安全的（{行：行，列：指数+ 1 }，pointtocompare）；
}）
减少（函数（a，b）{）
返回一个B；
}）；
}；
在一行中递归地生成规则组合
无功queencols =功能（大小）{
如果（1 = size）{
返回的时间间隔（1，boardersize）。地图（功能（我）{ return {我}；}）；
}
第一集 / /在所有符合扩展的列的列组成的规则，然后使用减少降维，最后利用有效组合滤波器不遵守规则
返回queencols（尺寸1）
。地图（功能（queencol）{）
返回的时间间隔（1，boardersize）。地图（功能（行）{）
返回queencol.concat（行）；
}）；
}）
减少（函数（a，b）{）
返回a.concat（B）；
}）
过滤（有效）；
}；
昆斯功能入口
返回queencols（boardersize）；
}；

console.log（皇后（8））；
输出结果：
{ 1, 5, 8，6, 3, 7，2, 4 }，
{ 1, 6, 8，3, 7, 4，2, 5 }，
…
{ 8, 3, 1，6, 2, 5，7, 4 }，
{ 8, 4, 1，3, 6, 2，7, 5 } }

ps：扩展n皇后问题

当棋手Max Bezzel提出的八皇后问题（八皇后问题）1848，他可能没有想到。100多年后，这一问题已成为一个最重要的必修课，编程学习。八皇后问题听起来很简单：棋盘上的八个皇后，八皇后互不攻击（国际象棋棋盘是8×8平方，女王可以任意的向任意多步方向八个方向）。虽然这个问题有92个解决方案，用手找到一个解决方案是不容易的。下图是解决方案之一：
有八皇后问题的许多变种，但它永远不会比下面的变异版本更帅：请设计一个方案，把女王在每一行是一个无限大的棋盘柱，使所有皇后互不攻击。具体地说，假定左下角这个棋盘无限行从底部到顶部的起源，有无限多的列从左到右。你需要找出所有正整数的排列，A1，A2，A3，……这样当你把第一个皇后放在第一排A1的时候，把第二个皇后放在第二列A2柱上，这样，就没有两个皇后会互相攻击。
下面给出了一个非常简单和巧妙的构造。首先，我们给出了五皇后问题的一个解决方案，其中一个昆斯在左下角取格是很重要的。
接下来，我们将五皇后的解决方案扩展到25皇后，这是基于五皇后本身的布局。
例如，同一组中的五个皇后显然不会互相攻击。不同群体的皇后显然不会互相攻击。这是一个25皇后的解决方案，满足要求。请注意，在扩展后，以前填充的部分没有改变。

下一步该怎么办是的，我们25皇后复制了五份，然后按照五皇后的布局排列，然后延伸到125皇后！
一个无穷皇后问题的解可以通过像这样的填充部分的连续展开来产生。