编辑代码

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

void (async function () {
  // 读取矩阵的行数和列数
  const row = Number(await readline());
  const tate = Number(await readline());

  // 读取矩阵数据
  const matrix = [];
  for (let i = 0; i < row; i++) {
    matrix.push((await readline()).split(" ").map(Number));
  }

  // 创建访问标记数组，用于记录已访问的位置
  const visited = new Array(row).fill(0).map(() => new Array(tate).fill(false));

  // 定义四个方向的偏移量：右、下、左、上
  const offsets = [
    [0, 1], // 右
    [1, 0], // 下
    [0, -1], // 左
    [-1, 0], // 上
  ];

  /**
   * BFS函数：从起点(0,0)到终点(row-1,tate-1)寻找路径
   * 每次选择相邻位置中值最大的位置移动
   * @param {number} i - 起始位置的行坐标
   * @param {number} j - 起始位置的列坐标
   * @returns {Array} - 返回路径上的所有值
   */
  const bfs = (i, j) => {
    // 存储路径上的值
    const line = [];
    // 将起点值加入路径
    line.push(matrix[i][j]);

    // 初始化BFS队列，加入起点
    const queue = [[i, j]];
    // 标记起点为已访问
    visited[i][j] = true;

    // BFS主循环
    while (queue.length > 0) {
      // 取出队列中的第一个位置
      const [x, y] = queue.shift();

      // 如果到达终点，返回路径
      if (x === row - 1 && y === tate - 1) {
        return line;
      }

      // 记录当前可移动位置中的最大值和对应坐标
      let maxLen = -Infinity;
      let bastIdx = [];

      // 向四个方向扩展
      for (const [dx, dy] of offsets) {
        const nx = x + dx;
        const ny = y + dy;

        // 检查新位置是否有效：
        // 1. 不越界
        // 2. 未被访问过
        if (nx >= 0 && nx < row && ny >= 0 && ny < tate && !visited[nx][ny]) {
          const val = matrix[nx][ny];
          // 更新最大值和对应坐标
          if (val > maxLen) {
            maxLen = val;
            bastIdx = [nx, ny];
          }
        }
      }

      // 如果找到可移动的位置
      if (maxLen !== -Infinity) {
        // 将最佳位置加入队列
        queue.push(bastIdx);
        // 标记为已访问
        visited[bastIdx[0]][bastIdx[1]] = true;
        // 将值加入路径
        line.push(maxLen);
      }
    }

    // 如果无法到达终点，返回当前路径
    return line;
  };

  // 从起点(0,0)开始BFS
  const result = bfs(0, 0);
  // 输出路径上的最小值
  console.log(Math.min(...result));
})();