leetcode 算法题994 (简单260) 腐烂的橘子

leetcode 算法题994 (简单260) 腐烂的橘子

• 题目介绍

在给定的网格中，每个单元格可以有以下三个值之一：
  值 0 代表空单元格；
  值 1 代表新鲜橘子；
  值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。
返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。
如果不可能，返回 -1。

• 示例

输入：[[2,1,1],[1,1,0],[0,1,1]]
输出：4

输入：[[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。

输入：[[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。

• 提示

1 <= grid.length <= 10
1 <= grid[0].length <= 10
grid[i][j] 仅为 0、1 或 2

• 解法一

/**
 * @param {number[][]} grid
 * @return {number}
 */
var orangesRotting = function(grid) {
    let sum = i = count = 0;
    while(i < grid.length) {
      let j = 0;
      while(j < grid[i].length) {
        if(grid[i][j++] === 1) {
          sum++;
        }
      }
      i++;
    }
    while(sum > 0) {
      let x = 0, bad = new Set();
      while(x < grid.length) {
        let y = 0;
        while(y < grid[x].length) {
          if(grid[x][y] === 2) {
            bad = new Set([...bad, ...newBadOranges(grid, x, y)]);
          }
          y++;
        }
        x++;
      }
      if(bad.size === 0) {
        return -1;
      }
      for(let p of bad) {
        if(p) {
          let point = p.split(',')
          grid[point[0]][point[1]] = 2;
        }
      }
      sum -= bad.size;
      count++;
    }
    return count;
};

const newBadOranges = (grid, x, y) => {
  let set = new Set();
  if(x > 0) {
    if(grid[x - 1][y] === 1) {
      set.add([x - 1, y].join())
    }
  }
  if(x < grid.length - 1) {
    if(grid[x + 1][y] === 1) {
     set.add([x + 1, y].join())
    }
  }
  if(y > 0) {
    if(grid[x][y - 1] === 1) {
      set.add([x, y - 1].join())
    }
  }
  if(y < grid[x].length - 1) {
    if(grid[x][y + 1] === 1) {
      set.add([x, y + 1].join())
    }
  }
  return set;
}

执行用时 : 116 ms, 在所有 JavaScript 提交中击败了46.30%的用户

内存消耗 : 38 MB, 在所有 JavaScript 提交中击败了16.67%的用户

• 解法二

/**
 * @param {number[][]} grid
 * @return {number}
 */
var orangesRotting = function(grid) {
    let sum = i = count = 0;
    while(i < grid.length) {
      let j = 0;
      while(j < grid[i].length) {
        if(grid[i][j++] === 1) {
          sum++;
        }
      }
      i++;
    }
    while(sum > 0) {
      let x = bad = 0;
      while(x < grid.length) {
        let y = 0;
        while(y < grid[x].length) {
          if(grid[x][y] === 2) {
            badOranges(grid, x, y);
          }
          y++;
        }
        x++;
      }
      x = 0;
      while(x < grid.length) {
        let y = 0;
        while(y < grid[x].length) {
          if(grid[x][y] === 3) {
            grid[x][y] = 2;
            bad++;
          }
          y++;
        }
        x++;
      }
      if(!bad) {
        return -1;
      }
      sum -= bad;
      count++;
    }
    return count;
};

const badOranges = (grid, x, y) => {
  if(x > 0) {
    if(grid[x - 1][y] === 1) {
      grid[x - 1][y] = 3;
    }
  }
  if(x < grid.length - 1) {
    if(grid[x + 1][y] === 1) {
     grid[x + 1][y] = 3;
    }
  }
  if(y > 0) {
    if(grid[x][y - 1] === 1) {
      grid[x][y - 1] = 3;
    }
  }
  if(y < grid[x].length - 1) {
    if(grid[x][y + 1] === 1) {
      grid[x][y + 1] = 3;
    }
  }
}

执行用时 : 100 ms, 在所有 JavaScript 提交中击败了75.93%的用户

内存消耗 : 35.2 MB, 在所有 JavaScript 提交中击败了100.00%的用户