Question

我是新开发者

我的代码有问题，不知道是什么问题

我的迷宫代码有效，但不能解决迷宫

有人可以帮助我了解问题所在吗？或者有其他解决方法？

    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 maze(myMaze){
        		
            
            this.find = function(col,row){
            console.log(row,col,myMaze[row][col])
          		if(myMaze[row][col] == 2){
              	console.log('done')
              }
              if(myMaze[row][col] == 1){
              	console.log('we on the right way')
                if(row < myMaze.length - 1){
                	this.find(col,row+1)
                }
                if(col< myMaze[row].length -1){
                	this.find(col+1,row)
                }
                if(row > 0){
                	this.find(col,row-1)
                }
                if(col > 0){
                this.find(col-1,row)
                }
              }
            }
            
        }
        var maze= new maze(myMaze)
        maze.find(0,3)

Answer 1

主要问题是您的算法运行成圆形：从单元格B将访问它之前访问过的单元格A，然后从该单元格进行更深的递归以再次到达单元格B，这种情况将永远持续下去。最终，调用堆栈将耗尽内存。

这可以通过跟踪已访问的单元格来解决，因此不会再次访问它们。尽管可以使用数组完成此操作，但为此使用Set更为有效。

第二，对maze构造函数和maze实例使用相同的名称。这将使得不可能连续解决两个迷宫。取而代之的是，按照惯例将构造函数命名为首字母大写：Maze。

此外，如果仅输出算法已找到目标单元的事实，则您将没有有关所找到路径的任何信息。最好返回路径，并让呼叫者按自己的意愿处理。

最后，没有理由在实例上创建find方法：更好的做法是在原型上定义它，以便即使您创建多个迷宫实例也只需创建一次

我还建议放弃老式的构造函数，而使用ES6 class语法，这种语法已经存在了几年。

您可以在此处进行编码：

class Maze {
    constructor(maze) {
        this.maze = maze;
        this.width = maze[0].length;
        this.height = maze.length;
    }
    // Added optional argument to indicate cells that should not be visited
    find(col, row, visited = new Set) { 
        // Create a unique reference for the current cell
        const cellId = row * this.width + col; 
        // Check that this cell lies within the grid, has a non-zero value, 
        //    and has not been visited before
        if (!this.maze[row] || !this.maze[row][col] || visited.has(cellId)) {
            return; // No success
        }
        visited.add(cellId); // Mark this cell as visited, so it is not visited a second time.
        //console.log("visiting: ", col, row); // Uncomment to see progress
        if (this.maze[row][col] == 2) { // Bingo!
            return [[col, row]]; // Return the path that will be extended during backtracking
        }
        // Loop through the 4 directions
        for (const [addcol, addrow] of [[0, 1],[1, 0],[0, -1],[-1, 0]]) {
            const found = this.find(col+addcol, row+addrow, visited);
            // If found, prepend current cell to partial solution and get out of recursion
            if (found) return [[col, row], ...found]; 
        }
    }
}

const 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]
];


const maze = new Maze(myMaze);
const path = maze.find(0,3);
console.log(JSON.stringify(path));

Answer 2

我保留一个数组来跟踪已被访问的索引。可以编辑以查看要观看的路径

async function import(specifier) {
  const referrer = GetActiveScriptOrModule().specifier;
  const url = new URL(specifier, referrer);
  if (moduleMap.has(url)) {
    return moduleMap.get(url).Namespace;
  }
  const module = await FetchModuleSomehow(url);
  moduleMap.set(url, module);
  return module.Namespace;
}

我的迷宫代码算法无法解决-javascript

2 个答案: