Javascript 算法：生成骑士移动到所有棋盘格的路径 问题描述

我试图得到一个算法，可以找到一个骑士可以在棋盘上移动的可能的移动序列的路径，并且访问所有的方块而不重复任何方块。如下图所示，这是可能的

我的方法 为了尝试实现这一点，我遵循了以下步骤

使用

所有方块创建了一个数组
['a1'，'a2'，'a3'，…，'h7'，'h8']

创建了另一个

已访问正方形数组

。初始值为空

[]

为每个方块创建一个包含

路径的数组的函数。这表示骑士可以从其他方块移动到的方块

{
“a8”：[“c7”、“b6”]，
“a7”：[“c6”、“b5”、“c8”]，
“a6”：[“c5”、“b4”、“c7”、“b8”]，
...
“h3”：[“f2”、“g1”、“f4”、“g5”]，
“h2”：[“f1”、“f3”、“g4”]，
“h1”：[“f2”，“g3”]
}

创建了一个

getNextNode（）

函数以返回所访问节点的最大成本

最后，我尝试用以下步骤求解最长路径

while（this.squaresNotVisited.length>0）{
const nexterm=this.getNextNode（）；
const currentCost=this.pathCosts[nexterm[0]]；
const nextpath:string[]=this.path[nextTerm[0]]；
nextPath.forEach（正方形=>{
if（此.pathCosts[square]！this.squaresVisited.includes（x）
);
}

下面是完整的Javascript代码

类AppComponent{
董事会={
列：[“a”、“b”、“c”、“d”、“e”、“f”、“g”、“h”]，
行：[8,7,6,5,4,3,2,1]
};
allSquares=this.board.columns.reduce(
（上一页，下一页）=>[…上一页，…this.board.rows.map（x=>next+x）]，
[]
);
currentKnightPosition=“h5”；
平方可视=[]；
squaresNotVisited=[…this.allSquares]；
nextPossibleKnightPosition=currentKnightPosition=>{
const row=this.board.columns.indexOf（currentKnightPosition[0]）；
常量列=编号（currentKnightPosition[1]）-1；
返回[
[第1列第2行]，
[第1列第2行]，
[第2列第1行]，
[第2列第+1行]，
[列+1，行-2]，
[列+1，行+2]，
[第2列，第1行]，
[第+2列第+1行]
]
.过滤器(
（[row，column]）=>列>=0&&column<8&&row>=0&&row<8
)
.地图(
（[行，列]）=>
this.board.columns[column]+this.board.rows[8-行-1]
);
};
路径=this.allSquares.reduce(
（上一页，下一页）=>({
…上一页，
[下一步]：此.nextPossibleKnightPosition（下一步）
}),
{}
);
isNextSquare=square=>
此.nextPossibleKnightPosition（此.currentKnightPosition）。包括(
广场
);
成本={[this.currentKnightPosition]：0}；
路径成本={
…这个。所有的方块。减少(
（上一个，下一个）=>（{…上一个，[下一个]：-无穷大}），
{}
),
[此.currentKnightPosition]：0
};
GetNexterm=（）=>{
让NonListed=Object.entries（this.pathCosts）.filter(
（[x，y]）=>！此.squaresvisted.包括（x）
);
const maxPath=Math.max（…Object.values（nonlisted.map（（[，x]）=>x））；
返回nonlisted.find（（[，x]）=>x==maxPath）；
};
costsCalc=（）=>{
while（this.squaresNotVisited.length>0）{
const nexterm=this.getnexterm（）；
const currentCost=this.pathCosts[nexterm[0]]；
const nextpath=this.path[nextTerm[0]]；
nextPath.forEach（正方形=>{
if（此.pathCosts[square]！this.squaresVisited.includes（x）
);
}
};
恩戈尼尼特（）{
这个.costsCalc（）；
log（Math.max（…Object.values（this.pathCosts）））
}
}
const app=新的AppComponent（）；
app.ngOnInit（）

您的函数被卡住了 在每一步中，您的方法只需选择最长的路径并更新其所有邻居。这并不是撤销决定，这就是为什么它被困在52的路径长度上

当您发现当前解决方案不起作用时，您必须返回，即

可能的实施 …使用

const findPath=（骑士位置）=>{
if（squaresVisited.size==allSquares.length-1）返回[knightPosition]
方形视野。添加（骑士位置）
常量邻居=路径[骑士位置]
.filter（邻居=>！squaresVisited.has（邻居））
.map（邻居=>{
const neighborCount=路径[邻居]
.filter（square=>！squaresVisited.has（square））
.长度
返回{
位置：邻居，
计数：邻居计数
}
})
const minneighborscont=Math.min（…neights.map（{count}=>count））
const minNeighbors=neighborks.filter（neighbork=>neighbork.count==minneighborscont）
为（明尼堡的康斯特明尼堡）{
const{position，count}=minNeighbor
const path=findPath（位置）
如果（路径）返回[骑士位置，…路径]
}
方形视野。删除（骑士位置）
}

完整的工作示例

const board={
列：[“a”、“b”、“c”、“d”、“e”、“f”、“g”、“h”]，
行：[8,7,6,5,4,3,2,1]
};
const allSquares=board.columns.reduce(
（上一页，下一页）=>[…上一页，…board.rows.map（x=>next+x）]，
[]
);
const nextPossibleKnightPositions=currentKnightPosition=>{
常量行=board.columns.indexOf（currentKnightPosition[0]）；
常量列=编号（currentKnightPosition[1]）-1；
返回[
[第1列第2行]，
[第1列第2行]，
[第2列第1行]，
[第2列第+1行]