生命游戏

难度: Medium

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

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

如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
如果死细胞周围正好有三个活细胞，则该位置死细胞复活；

下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。给你 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] 为 0 或 1

进阶：

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

Submission

运行时间: 22 ms

内存: 0.0 MB

class Solution:
    def gameOfLife(self, board: List[List[int]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        m, n = len(board), len(board[0])

        def affect(x, y):
            for dx in (-1, 0 ,1):
                for dy in (-1, 0, 1):
                    if dx == 0 and dy == 0:
                        continue
                    if 0 <= x + dx < m and 0 <= y + dy < n:
                        board[x + dx][y + dy] += 10
        
        for x in range(m):
            for y in range(n):
                # 不能只写 “if board[x][y] == 1:”
                # 否则会漏掉早先被影响的细胞
                if board[x][y] % 10 == 1:
                    affect(x, y)
        
        def update(x, y):
            live_neighbors = board[x][y] // 10 
            live_self = board[x][y] % 10
            if live_self == 1 and live_neighbors < 2:
                board[x][y] = 0
            elif live_self == 1 and live_neighbors in (2, 3):
                board[x][y] = 1
            elif live_self == 1 and live_neighbors > 3:
                board[x][y] = 0
            elif live_self == 0 and live_neighbors == 3:
                board[x][y] = 1
            else:
                board[x][y] = live_self
        
        for x in range(m):
            for y in range(n):
                update(x, y)

# follow up 的第二个问题是关于解法的可扩展性的
# 以上解法可以很方便地拓展到 board 为极度稀疏矩阵的情形，很好想
# 对极大尺寸的矩阵，还可以三行三行地读取处理

Explain

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

时间复杂度: O(m * n)

空间复杂度: O(1)

class Solution:
    def gameOfLife(self, board: List[List[int]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        m, n = len(board), len(board[0])

        def affect(x, y):
            for dx in (-1, 0 ,1):
                for dy in (-1, 0, 1):
                    if dx == 0 and dy == 0:
                        continue
                    if 0 <= x + dx < m and 0 <= y + dy < n:
                        board[x + dx][y + dy] += 10  # 标记周围活细胞数量
        
        for x in range(m):
            for y in range(n):
                if board[x][y] % 10 == 1:
                    affect(x, y)  # 对活细胞周围的细胞进行标记
        
        def update(x, y):
            live_neighbors = board[x][y] // 10 
            live_self = board[x][y] % 10
            if live_self == 1 and live_neighbors < 2:
                board[x][y] = 0
            elif live_self == 1 and live_neighbors in (2, 3):
                board[x][y] = 1
            elif live_self == 1 and live_neighbors > 3:
                board[x][y] = 0
            elif live_self == 0 and live_neighbors == 3:
                board[x][y] = 1
            else:
                board[x][y] = live_self  # 更新细胞状态
        
        for x in range(m):
            for y in range(n):
                update(x, y)  # 更新所有细胞状态

Explore

在原地算法中，使用十位数来表示周围活细胞的数量，个位数表示当前状态，这样做的优点是可以在不额外使用空间的情况下，同时保存当前状态和周围状态的信息，这对于状态更新非常关键。这种编码方式使得在遍历和更新过程中能够直接在原数组上操作，而不需要额外的存储空间。当然，还有其他编码方式，例如使用不同的位操作（如位标记法）来存储这些信息，或者使用更高的位来标记更多的状态信息，但基本原理相同，都是为了在有限的空间内存储更多的状态信息以支持复杂的逻辑判断。

在影响函数中跳过(dx == 0 && dy == 0)的情况，是因为这表示细胞自身的位置。在计算一个细胞周围活细胞的数量时，我们不应该将细胞自己计算在内。因此，我们需要跳过这种情况以确保只计算周围的细胞，而不是包括细胞自身。这是为了准确地统计周围活细胞的数量，避免自身状态对计数造成干扰。

函数`affect`在处理边界细胞时，通过条件`0 <= x + dx < m`和`0 <= y + dy < n`确保了不会发生数组越界错误。这些条件检查确保了即使对于边界上的细胞，任何试图访问矩阵外部的操作都会被阻止。因此，该函数已经妥善处理了所有边界情况，避免了数组越界的问题。

更新状态的逻辑正确地实现了题目中描述的规则。对于活细胞，根据周围活细胞的数量决定其生存或死亡；对于死细胞，当其周围有三个活细胞时变为活细胞。此外，函数中包括了所有必要的条件判断来确保每种情况都能得到正确处理。由于逻辑和条件判断是基于题目规则明确编写的，因此在正常情况下不太可能出现逻辑判断错误。然而，如果输入数据本身存在问题，或在实际实现中误修改了逻辑或参数，仍可能导致不正确的结果。