leetcode
leetcode 251 ~ 300
生命游戏

生命游戏

难度:

标签:

题目描述

根据 百度百科 , 生命游戏 ,简称为 生命 ,是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。

给定一个包含 m × n 个格子的面板,每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态: 1 即为 活细胞 (live),或 0 即为 死细胞 (dead)。每个细胞与其八个相邻位置(水平,垂直,对角线)的细胞都遵循以下四条生存定律:

  1. 如果活细胞周围八个位置的活细胞数少于两个,则该位置活细胞死亡;
  2. 如果活细胞周围八个位置有两个或三个活细胞,则该位置活细胞仍然存活;
  3. 如果活细胞周围八个位置有超过三个活细胞,则该位置活细胞死亡;
  4. 如果死细胞周围正好有三个活细胞,则该位置死细胞复活;

下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的,其中细胞的出生和死亡是同时发生的。给你 m x n 网格面板 board 的当前状态,返回下一个状态。

 

示例 1:

输入:board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
输出:[[0,0,0],[1,0,1],[0,1,1],[0,1,0]]

示例 2:

输入:board = [[1,1],[1,0]]
输出:[[1,1],[1,1]]

 

提示:

  • m == board.length
  • n == board[i].length
  • 1 <= m, n <= 25
  • board[i][j]01

 

进阶:

  • 你可以使用原地算法解决本题吗?请注意,面板上所有格子需要同时被更新:你不能先更新某些格子,然后使用它们的更新后的值再更新其他格子。
  • 本题中,我们使用二维数组来表示面板。原则上,面板是无限的,但当活细胞侵占了面板边界时会造成问题。你将如何解决这些问题?

代码结果

运行时间: 22 ms, 内存: 0.0 MB


// Java Stream解法(受限于Stream的使用场景,这里仅用作计数):
// 题目思路:我们无法直接用Stream来遍历和更新二维数组,但可以用Stream来辅助计数活细胞。
 
public class GameOfLifeStream {
    public void gameOfLife(int[][] board) {
        int m = board.length, n = board[0].length;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                long liveNeighbors = countLiveNeighbors(board, i, j);
                if (board[i][j] == 1 && (liveNeighbors < 2 || liveNeighbors > 3)) {
                    board[i][j] = 2;
                }
                if (board[i][j] == 0 && liveNeighbors == 3) {
                    board[i][j] = -1;
                }
            }
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (board[i][j] == 2) board[i][j] = 0;
                if (board[i][j] == -1) board[i][j] = 1;
            }
        }
    }
    private long countLiveNeighbors(int[][] board, int i, int j) {
        int[][] directions = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
        return Arrays.stream(directions)
                .filter(dir -> {
                    int x = i + dir[0], y = j + dir[1];
                    return x >= 0 && x < board.length && y >= 0 && y < board[0].length && Math.abs(board[x][y]) == 1;
                })
                .count();
    }
}

解释

方法:

本题解采用的是原地算法,通过将细胞的状态进行编码来避免额外空间的使用。将每个细胞的状态分为两部分:个位数表示当前状态(1为活细胞,0为死细胞),十位数表示周围活细胞的数量。首先遍历一遍矩阵,对于每个活细胞,将其周围的细胞的十位数加1,表示该细胞周围的活细胞数量增加。然后再次遍历矩阵,根据每个细胞的十位数(周围活细胞数量)和个位数(当前状态),按照题目给定的规则更新细胞的状态。

时间复杂度:

O(m * n)

空间复杂度:

O(1)

代码细节讲解

🦆
为什么在原地算法中,细胞状态的编码方式选择用十位数表示周围活细胞的数量,而个位数表示当前状态?是否有其他编码方式可以实现相同的功能?
在原地算法中,使用十位数来表示周围活细胞的数量,个位数表示当前状态,这样做的优点是可以在不额外使用空间的情况下,同时保存当前状态和周围状态的信息,这对于状态更新非常关键。这种编码方式使得在遍历和更新过程中能够直接在原数组上操作,而不需要额外的存储空间。当然,还有其他编码方式,例如使用不同的位操作(如位标记法)来存储这些信息,或者使用更高的位来标记更多的状态信息,但基本原理相同,都是为了在有限的空间内存储更多的状态信息以支持复杂的逻辑判断。
🦆
在影响函数中,为什么选择跳过(dx == 0 && dy == 0)的情况?这个条件的目的是什么?
在影响函数中跳过(dx == 0 && dy == 0)的情况,是因为这表示细胞自身的位置。在计算一个细胞周围活细胞的数量时,我们不应该将细胞自己计算在内。因此,我们需要跳过这种情况以确保只计算周围的细胞,而不是包括细胞自身。这是为了准确地统计周围活细胞的数量,避免自身状态对计数造成干扰。
🦆
函数 `affect` 中对于边界细胞的处理(例如在矩阵的边缘),是否有考虑到所有的边界情况,确保不会有数组越界的错误?
函数`affect`在处理边界细胞时,通过条件`0 <= x + dx < m`和`0 <= y + dy < n`确保了不会发生数组越界错误。这些条件检查确保了即使对于边界上的细胞,任何试图访问矩阵外部的操作都会被阻止。因此,该函数已经妥善处理了所有边界情况,避免了数组越界的问题。
🦆
更新状态的逻辑中,对于活细胞和死细胞的处理逻辑是否完全按照题目的规则实现?是否有可能某些情况下逻辑判断出现错误?
更新状态的逻辑正确地实现了题目中描述的规则。对于活细胞,根据周围活细胞的数量决定其生存或死亡;对于死细胞,当其周围有三个活细胞时变为活细胞。此外,函数中包括了所有必要的条件判断来确保每种情况都能得到正确处理。由于逻辑和条件判断是基于题目规则明确编写的,因此在正常情况下不太可能出现逻辑判断错误。然而,如果输入数据本身存在问题,或在实际实现中误修改了逻辑或参数,仍可能导致不正确的结果。

相关问题

矩阵置零

给定一个 m x n 的矩阵,如果一个元素为 0 ,则将其所在行和列的所有元素都设为 0 。请使用 原地 算法

 

示例 1:

输入:matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出:[[1,0,1],[0,0,0],[1,0,1]]

示例 2:

输入:matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
输出:[[0,0,0,0],[0,4,5,0],[0,3,1,0]]

 

提示:

  • m == matrix.length
  • n == matrix[0].length
  • 1 <= m, n <= 200
  • -231 <= matrix[i][j] <= 231 - 1

 

进阶:

  • 一个直观的解决方案是使用  O(mn) 的额外空间,但这并不是一个好的解决方案。
  • 一个简单的改进方案是使用 O(m + n) 的额外空间,但这仍然不是最好的解决方案。
  • 你能想出一个仅使用常量空间的解决方案吗?