【LeetCode每日一题】【BFS模版与例题】【二维数组】130被围绕的区域 && 994 腐烂的橘子

前几天写过一篇BFS比较基础版的遍历
【LeetCode每日一题】【BFS模版与例题】863.二叉树中所有距离为 K 的结点

，可以先看一下再看本文

用 BFS 算法遍历二维数组

遍历二维矩阵：二维矩阵中的一个位置看做一个节点，这个节点的上下左右四个位置就是相邻节点。

130 被围绕的区域

解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的’O’ 都不会被填充为’X’。 任何不在边界上，或不与边界上的’O’ 相连的’O’ 最终都会被填充为’X’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

思路：

遍历二维数组，找到边界为‘o’的点，利用BFS非递归框架将与之相连的’o‘都替换为随便一个字母，这里替换’#’。剩下的‘o’就是不与边界连接的 ‘o’。

/**
 * @param {character[][]} board
 * @return {void} Do not return anything, modify board in-place instead.
 */
var solve = function (board) {
  let m = board.length
  let n = board[0].length
  for (let i = 0; i < m; i++) {
    for (let j = 0; j < n; j++) {
		// 从边界的‘o’出发
      let flag = i === 0 || j === 0 || i === m - 1 || j === n - 1
      if (flag && board[i][j] === 'O') {
        bfs(board, i, j)
      }
    }
  }

 // 对操作后的数组进行刷新。
  for (let i = 0; i < m; i++) {
    for (let j = 0; j < n; j++) {
		// 被包围的，可以去除
      if (board[i][j] === 'O') {
        board[i][j] = 'X'
      }
		// 边界的，不可以去除，还原回来。
      if (board[i][j] === '#') {
        board[i][j] = 'O'
      }
    }
  }

  return board
}

const bfs = (board, i, j) => {
  let queue = []
  let visited = new Set()
  queue.push([i, j])
  visited.add(`${i},${j}`)

  while (queue.length > 0) {
    let [x, y] = queue.shift()
    board[x][y] = '#'

    // 向上
    if (
      x - 1 >= 0 &&
      board[x - 1][y] === 'O' &&
      !visited.has(`${x - 1},${y}`)
    ) {
      queue.push([x - 1, y])
      visited.add(`${x - 1},${y}`)
    }

    // 向下
    if (
      x + 1 < board.length &&
      board[x + 1][y] === 'O' &&
      !visited.has(`${x + 1},${y}`)
    ) {
      queue.push([x + 1, y])
      visited.add(`${x - 1},${y}`)
    }

    // 向左
    if(y - 1 >= 0 && board[x][y - 1] === 'O' && !visited.has(`${x},${y - 1}`)){
      queue.push([x, y - 1])
      visited.add(`${x},${y - 1}`)
    }

    // 向右
    if(y + 1 < board[0].length && board[x][y + 1] === 'O' && !visited.has(`${x},${y + 1}`)){
      queue.push([x, y + 1])
      visited.add(`${x},${y + 1}`)
    }
  }
}

994 腐烂的橘子

错误的思路：

遍历二维数组，找到腐烂的橘子，利用这个橘子BFS搜索附近的橘子，记录将连接的橘子变成烂橘子的时间。将二维数组中烂橘子将其他橘子变成烂橘子的时间相加。

错误的题解。

/**
 * @param {number[][]} grid
 * @return {number}
 */
var orangesRotting = function (grid) {
  if (!grid.flat().includes(1)) {
    return 0;
  }

  let step = -1;
  let row = grid.length;
  let col = grid[0].length;

  for (let i = 0; i < row; i++) {
    for (let j = 0; j < col; j++) {
      if (grid[i][j] == 2) {
        step += bfs(grid, i, j);
      }
    }
  }
  if (grid.flat().includes(1)) {
    return -1;
  }
  return step;
};

const bfs = (grid, i, j) => {
  let queue = [[i, j]];
  let visited = new Set();
  visited.add(`${i},${j}`);

  let step = 0;

  while (queue.length) {
    let size = queue.length;
    for (let k = 0; k < size; k++) {
      let [x, y] = queue.shift();
      grid[x][y] = 0;

      // 向上
      if (x - 1 >= 0 && grid[x - 1][y] == 1 && !visited.has(`${x - 1},${y}`)) {
        queue.push([x - 1, y]);
        visited.add(`${x - 1},${y}`);
      }

      // 向下
      if (
        x + 1 < grid.length &&
        grid[x + 1][y] == 1 &&
        !visited.has(`${x + 1},${y}`)
      ) {
        queue.push([x + 1, y]);
        visited.add(`${x + 1},${y}`);
      }

      // 向左
      if (y - 1 >= 0 && grid[x][y - 1] == 1 && !visited.has(`${x},${y - 1}`)) {
        queue.push([x, y - 1]);
        visited.add(`${x},${y - 1}`);
      }

      // 向右
      if (
        y + 1 < grid[0].length &&
        grid[x][y + 1] == 1 &&
        !visited.has(`${x},${y + 1}`)
      ) {
        queue.push([x, y + 1]);
        visited.add(`${x},${y + 1}`);
      }
    }
    step++;
  }
  return step;
};

错误的原因：

假如二维数组左上角和右下角分别有一个烂橘子。它们应该能够同时让四周的橘子变烂，而不是先后顺序的。因此，多源的BFS，应该将每个源都放置在queue里面。

var orangesRotting = function (grid) {
 // 特殊情况：本来就没有新鲜橘子的。
  if (!grid.flat().includes(1)) {
    return 0;
  }

  let step = -1;
  let row = grid.length;
  let col = grid[0].length;

  let queue = [];
  let visited = new Set();

  for (let i = 0; i < row; i++) {
    for (let j = 0; j < col; j++) {
		
			// 多源，每个烂橘子都应该放在queue，他们是属于同一层的。
      if (grid[i][j] == 2) {
        queue.push([i, j]);
        visited.add(`${i},${j}`);
      }
    }
  }

  step += bfs(grid, queue, visited);
	
	// 如果依然剩下新鲜的橘子，说明无法完成，返回-1；
  if (grid.flat().includes(1)) {
    return -1;
  }

  return step;
};

const bfs = (grid, queue, visited) => {

  let step = 0;
  while (queue.length) {

    let size = queue.length;
    for (let k = 0; k < size; k++) {
			
			// 将节点置为0
      let [x, y] = queue.shift();
      grid[x][y] = 0;

			// 向相邻的节点扩散。
      // 向上
      if (x - 1 >= 0 && grid[x - 1][y] != 0 && !visited.has(`${x - 1},${y}`)) {
        queue.push([x - 1, y]);
        visited.add(`${x - 1},${y}`);
      }

      // 向下
      if (
        x + 1 < grid.length &&
        grid[x + 1][y] != 0 &&
        !visited.has(`${x + 1},${y}`)
      ) {
        queue.push([x + 1, y]);
        visited.add(`${x + 1},${y}`);
      }

      // 向左
      if (y - 1 >= 0 && grid[x][y - 1] != 0 && !visited.has(`${x},${y - 1}`)) {
        queue.push([x, y - 1]);
        visited.add(`${x},${y - 1}`);
      }

      // 向右
      if (
        y + 1 < grid[0].length &&
        grid[x][y + 1] != 0 &&
        !visited.has(`${x},${y + 1}`)
      ) {
        queue.push([x, y + 1]);
        visited.add(`${x},${y + 1}`);
      }
    }
		// 每层遍历完都需要添加1分钟
    step++;
  }
  return step;
};