迷宫问题

const rl = require("readline").createInterface({ input: process.stdin });
const iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void (async function () {
    // Write your code here
    const [N, M] = (await readline()).split(" ").map(Number);
    const matrix = [];
    let i = 0;
    while (i++ < N) {
        matrix.push((await readline()).split(" ").map(Number));
    }

    const [x, y] = [0, 0];
    let res = null;

    const recursion = (i, j, previousDirection, prevPath) => {
        if (res !== null) return;
        if (i < 0 || i >= N || j < 0 || j >= M) return;

        const path = [...prevPath];
        path.push(`(${i},${j})`);

        if (i === N - 1 && j === M - 1) return (res = path);

        // UP
        if (
            previousDirection !== "DOWN" &&
            i - 1 >= 0 &&
            matrix[i - 1][j] !== 1
        ) {
            recursion(i - 1, j, "UP", path);
        }
        // RIGHT
        if (
            previousDirection !== "LEFT" &&
            j + 1 < M &&
            matrix[i][j + 1] !== 1
        ) {
            recursion(i, j + 1, "RIGHT", path);
        }
        // DOWN
        if (previousDirection !== "UP" && i + 1 < N && matrix[i + 1][j] !== 1) {
            recursion(i + 1, j, "DOWN", path);
        }
        // LEFT
        if (
            previousDirection !== "RIGHT" &&
            j - 1 >= 0 &&
            matrix[i][j - 1] !== 1
        ) {
            recursion(i, j - 1, "LEFT", path);
        }
        return;
    };

    recursion(x, y, undefined, []);

    res.map((r) => console.log(r));
})();

const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
var flag=true,m,n,arr=[],res
function findWay(i,j,direction,path){
    if(i==m-1 && j==n-1){
        for(let i in path){
            console.log('('+path[i][0]+','+path[i][1]+')')
        }
    }
    if(i+1<m && arr[i+1][j]==0 && direction[1]!=0){
        findWay(i+1,j,[0,1,1,1],path.concat([[i+1,j]]))
    }
    if(i-1>=0 && arr[i-1][j]==0 && direction[0]!=0){
        findWay(i-1,j,[1,0,1,1],path.concat([[i-1,j]]))
    }
    if(j+1<n && arr[i][j+1]==0 && direction[3]!=0){
        findWay(i,j+1,[1,1,0,1],path.concat([[i,j+1]]))
    }
    if(j-1>=0 && arr[i][j-1]==0 && direction[2]!=0){
        findWay(i,j-1,[1,1,1,0],path.concat([[i,j-1]]))
    }
}
rl.on('line', function (line) {
    const tokens = line.split(' ');
    if (tokens[tokens.length-1]=='') tokens.pop()
    if(flag){
        m=parseInt(tokens[0]),n=parseInt(tokens[1])
        flag=false
    }
    else{
        arr.push(tokens.map((value,index,arr)=>{
            return parseInt(value)
        }))
        if(arr.length==m){
            //console.log(arr)
            findWay(0,0,[0,1,0,1],[[0,0]])
            arr=[]
            flag=true
        }
    }
});

Node环境的解法来一个 思路和其他语言的差不多

const readline = require('readline')
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
})
let N = 0
let M = 0
let arr = []
let Maze = []
let MazeResult = []
let count = 0
rl.on('line', line => {
  arr.push(line)
  if(arr.length == 1) {
    N = Number(arr[0].split(' ')[0])
    M = Number(arr[0].split(' ')[1])
  }
  if(arr.length == N+1) {
    Maze = arr.slice(1)
    Maze = Maze.map(item => {
       temp = item.split(' ')
      return temp
    })
    handleMaze(0, 0)
    MazeResult.forEach(item => {
      console.log(`(${item.row},${item.col})`)
    })
    N = 0
    M = 0
    arr = []
    Maze = []
    MazeResult = []
  }
})
 function handleMaze(row, col) {
    if (Maze[row][col] == 0) {
      MazeResult.push({row: row, col: col})
    }
    Maze[row][col] = 1
    if (row === N-1 && col === M-1) return
    if (col+1<M && Maze[row][col+1] == 0) { //right
      handleMaze(row, col+1)
    } else if (row+1<N && Maze[row+1][col] == 0) { //bottom
      handleMaze(row+1, col)
    } else if (col>=1&&Maze[row][col-1] == 0) { //left
      handleMaze(row, col-1)
    } else if (row>=1 && Maze[row-1][col] == 0) { //top
      handleMaze(row-1, col)
    } else { //noway
      MazeResult.pop()
      let pre = MazeResult.slice(-1)[0]
      handleMaze(pre.row, pre.col)
    }
  }