一天一大 lee(被围绕的区域)难度:中等-Day20200811

20200811

题目:

给定一个二维的矩阵，包含 'X' 和 'O'（字母 O）。

找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

示例

X X X X
X O O X
X X O X
X O X X

运行你的函数后，矩阵变为：

X X X X
X X X X
X X X X
X O X X

解释：

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

抛砖引玉

思路

根据解释的意思，从边界向内一层层循环
边界上遇到的 O，其标记不可替换(A)，以它为起点向其四周遍历，遇到与其相邻位置存在 O，则同样标记不可替换(A)
遍历标记后的矩阵，标记不可替换则填充 O，未标记则填充 x

深度优先搜索

/**
 * @param {character[][]} board
 * @return {void} Do not return anything, modify board in-place instead.
 */
var solve = function (board) {
  let n = board.length,
    m = board[0] ? board[0].length : 0
  if (n === 0) return
  // 首行-尾行
  for (let i = 0; i < n; i++) {
    dfs(board, i, 0)
    dfs(board, i, m - 1)
  }
  // 首列-尾列
  for (let i = 1; i < m - 1; i++) {
    dfs(board, 0, i)
    dfs(board, n - 1, i)
  }

  // 替换
  for (let i = 0; i < n; i++) {
    for (let j = 0; j < m; j++) {
      // 不可替换
      if (board[i][j] === 'A') {
        board[i][j] = 'O'
      } else if (board[i][j] === 'O') {
        // 可替换
        board[i][j] = 'X'
      }
    }
  }

  // 遇到X或者边界终止
  function dfs(board, x, y) {
    if (x < 0 || x >= n || y < 0 || y >= m || board[x][y] !== 'O') return
    // 边界上遇到O，与边界O相邻的位置出现O
    board[x][y] = 'A'
    dfs(board, x + 1, y)
    dfs(board, x - 1, y)
    dfs(board, x, y + 1)
    dfs(board, x, y - 1)
  }
}

广度优先搜索

不使用递归查询边界O及其相邻O
使用dp数组暂存不可替换O，并且逐个查询其相邻O节点

/**
 * @param {character[][]} board
 * @return {void} Do not return anything, modify board in-place instead.
 */
var solve = function (board) {
  let dx = [1, -1, 0, 0],
    dy = [0, 0, 1, -1],
    dp = [],
    n = board.length,
    m = board[0] ? board[0].length : 0
  if (n === 0) return

  for (let i = 0; i < n; i++) {
    // 首行 存在O的坐标
    if (board[i][0] === 'O') dp.push([i, 0])
    // 尾行 存在O的坐标
    if (board[i][m - 1] === 'O') dp.push([i, m - 1])
  }
  for (let i = 1; i < m - 1; i++) {
    // 首列 存在O的坐标
    if (board[0][i] == 'O') dp.push([0, i])
    // 尾列 存在O的坐标
    if (board[n - 1][i] == 'O') dp.push([n - 1, i])
  }

  while (dp.length) {
    let [x, y] = dp.shift()
    // 边界遇到O不可替换
    board[x][y] = 'A'
    // 查询边界O相邻位是否存在O，存在同样不可替换，且其相邻O同样不可替换
    for (let i = 0; i < 4; i++) {
      let i_x = x + dx[i],
        i_y = y + dy[i]
      if (i_x < 0 || i_y < 0 || i_x >= n || i_y >= m || board[i_x][i_y] !== 'O') continue
      dp.push([i_x, i_y])
    }
  }
  // 替换
  for (let i = 0; i < n; i++) {
    for (let j = 0; j < m; j++) {
      if (board[i][j] == 'A') {
        board[i][j] = 'O'
      } else if (board[i][j] == 'O') {
        board[i][j] = 'X'
      }
    }
  }
}