Javascript 这个迷宫解算器是怎么工作的？

下面的迷宫解算器是如何工作的？在我看来，只要它碰到除1或2以外的任何东西，它就会停止。当它达到0时，它怎么可能继续运行

var myMaze = [
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 1, 1, 1, 0, 0, 0, 0, 0],
  [1, 1, 1, 0, 1, 0, 0, 1, 1, 1],
  [0, 1, 0, 0, 1, 0, 0, 1, 0, 0],
  [0, 1, 1, 1, 1, 0, 1, 1, 1, 0],
  [0, 1, 0, 0, 1, 0, 1, 0, 1, 0],
  [0, 0, 0, 0, 1, 1, 1, 0, 1, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 1, 2],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
];

function MazeSolver(maze) {
  this.maze = maze;

  this.traverse = function (column, row) {
    if (this.maze[column][row] == 2) {
      console.log("We solved the maze at (" + column + ", " + row + ")");
    } else if (this.maze[column][row] == 1) {
      console.log("At valid position (" + column + ", " + row + ")");
      this.maze[column][row] = 9;
      if (column < this.maze.length - 1) {
        this.traverse(column + 1, row);
      }
      if (row < this.maze[column].length - 1) {
        this.traverse(column, row + 1);
      }
      if (column > 0) {
        this.traverse(column - 1, row);
      }
      if (row > 0) {
        this.traverse(column, row - 1);
      }
    }
  };
}

var ms = new MazeSolver(myMaze);
ms.traverse(3, 0);

var myMaze=[
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 0, 0, 0, 0, 0],
[1, 1, 1, 0, 1, 0, 0, 1, 1, 1],
[0, 1, 0, 0, 1, 0, 0, 1, 0, 0],
[0, 1, 1, 1, 1, 0, 1, 1, 1, 0],
[0, 1, 0, 0, 1, 0, 1, 0, 1, 0],
[0, 0, 0, 0, 1, 1, 1, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 2],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
];
函数迷宫解算器（迷宫）{
这个迷宫=迷宫；
this.traverse=函数（列、行）{
if（this.maze[列][行]==2）{
log（“我们在（“+column+”，“+row+”）解决了迷宫问题）；
}else if（this.maze[列][行]==1）{
log（“在有效位置（“+列+”，“+行+”）；
这个.迷宫[列][行]=9；
如果（列0）{
这是一次遍历（第1列，第2行）；
}
如果（行>0）{
这是一次遍历（列，第1行）；
}
}
};
}
var ms=新MazeSolver（myMaze）；
ms.traverse（3,0）；

这个问题已经在注释（递归）中得到了回答，但由于迷宫可以有多个完整的解决方案，因此我提供了修改版，它将记录从最短到最长的每个解决方案以及所采取的步骤数

var myMaze=[
[1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 0, 1, 0, 0, 1, 1, 1],
[0, 0, 1, 0, 1, 0, 0, 0, 0, 1],
[1, 1, 1, 0, 1, 1, 1, 1, 1, 1],
[0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 1, 1, 1, 1, 0, 1, 1, 1, 0],
[0, 1, 0, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 1, 0, 1, 1, 1, 0, 1, 0],
[1, 1, 0, 0, 0, 0, 0, 0, 1, 2],
[0, 1, 1, 1, 1, 1, 1, 1, 1, 0],
]
函数迷宫解算器（迷宫）{
这个迷宫
此值为0.1。解决方案=[]
this.traverse=函数（列、行、迷宫）{
常量路径=maze.map（（arr）=>arr.slice（））
if（路径[列][行]==2）{
此.solutions.push（路径）
}else if（路径[列][行]==1）{
路径[列][行]=8
if（列0）{
遍历（列-1，行，路径）
}
如果（行>0）{
遍历（列，行-1，路径）
}
}
}
this.solve=函数（列、行、迷宫）{
此.遍历（列、行、迷宫）
const solutions=this.solutions
.map（（解决方案）=>[
解决方案(
（acc，cur）=>acc+cur.filter（（e）=>e==8）。长度，
0
),
解决方案
])
.sort（（a，b）=>a[0]-b[0]）
解决方案。取消移位（[0，迷宫]）
解决方案。forEach（（sol）=>{
container.innerHTML+=！！sol[0]？（sol[0]+“步骤：”）：“问题：”
container.innerHTML+=“
”
sol[1][column][row]=“S”
sol[1]。forEach（（行）=>{
container.innerHTML+=row.map（e=>{
如果（e==0）返回“”
如果（e==8）返回“+”
如果（e==1）返回“”
如果（e==2）返回“F”
返回e
})
.join（“”）
container.innerHTML+=“
”
})
})
}
}
var ms=新的MazeSolver（myMaze）
ms.solve（3，0，myMaze）

div{
字体系列：monospace；
}

---

这个概念叫做；main函数有一个内部函数（

this.traverse

），它会一直调用自己，直到找到出口为止。它基本上是使用将零替换为向各个方向扩散的九，直到到达2。这是经典的递归迷宫求解方法，是深度优先搜索的一种应用，从某种意义上说，当它到达

0

时，它确实会停止，但在这种情况下，“It”是被调用函数的单个实例，如上所述，函数被递归调用。因此，当一个实例完成时，它的父实例将继续执行。@ChrisG一旦进入遍历方法且当前位置为0，它将在哪里再次调用自己？如果.maze[column][row]==0时遇到

0

，则不需要另一个if语句，它只返回，而下一个

if

尝试转到另一个方向。