LeetCode 289. 生命游戏

LeetCode 289. 生命游戏

根据 百度百科 ， 生命游戏 ，简称为 生命 ，是英国数学家约翰·何顿·康威在 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
进阶：
你可以使用原地算法解决本题吗？请注意，面板上所有格子需要同时被更新：你不能先更新某些格子，然后使用它们的更新后的值再更新其他格子。
本题中，我们使用二维数组来表示面板。原则上，面板是无限的，但当活细胞侵占了面板边界时会造成问题。你将如何解决这些问题？

蛮力法1

开一个二维数组就直接开始算

蛮力法2

优化一下，其实最多需要两行的辅助空间就行

class Solution:
    def gameOfLife(self, board: List[List[int]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        rows, cols = len(board), len(board[0])
        row = []
        for i in range(rows):
            row_current = [item for item in board[i]]
            for j in range(cols):
                arrows = [(-1, -1), (-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0),(1, -1),(0, -1)]
                counter = 0
                for di, dj in arrows:
                    if 0 <= i + di < rows and 0 <= j + dj < cols:
                        if di == -1:
                            status = row[j + dj]
                        elif di == 0:
                            status =  row_current[j + dj]
                        else:
                            status =  board[i + di][j + dj]
                        counter += status
                if board[i][j]:
                    if counter < 2:
                        board[i][j] = 0
                    elif counter <= 3:
                        board[i][j] = 1
                    else:
                        board[i][j] = 0
                else:
                    board[i][j] = int(counter == 3)

            row = row_current
        return board

蛮力法3
再优化一下，由于 1 <= m, n <= 25，直接把一行的状态转为一个整数，这样用两个整数替代了原来的两个数组

class Solution:
    def gameOfLife(self, board: List[List[int]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        rows, cols = len(board), len(board[0])
        row = 0
        for i in range(rows):
            row_current = 0
            for idx, item in enumerate(board[i]):
                if item:
                    row_current |= 1 << idx
            for j in range(cols):
                arrows = [(-1, -1), (-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0),(1, -1),(0, -1)]
                counter = 0
                for di, dj in arrows:
                    if 0 <= i + di < rows and 0 <= j + dj < cols:
                        if di == -1:
                            status = (row & (1 << j + dj)) >> j + dj
                        elif di == 0:
                            status =  (row_current & (1 << j + dj)) >> j + dj
                        else:
                            status =  board[i + di][j + dj]
                        counter += status
                if board[i][j]:
                    if counter < 2:
                        board[i][j] = 0
                    elif counter <= 3:
                        board[i][j] = 1
                    else:
                        board[i][j] = 0
                else:
                    board[i][j] = int(counter == 3)

            row = row_current
        return board

蛮力法4

官方某一题解定义了细胞死而复生后状态为2，使用一个中间状态解决数据被修改后不知道原状态的问题，最后把2刷为1即可

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

        neighbors = [(1,0), (1,-1), (0,-1), (-1,-1), (-1,0), (-1,1), (0,1), (1,1)]

        rows = len(board)
        cols = len(board[0])

        # 遍历面板每一个格子里的细胞
        for row in range(rows):
            for col in range(cols):

                # 对于每一个细胞统计其八个相邻位置里的活细胞数量
                live_neighbors = 0
                for neighbor in neighbors:

                    # 相邻位置的坐标
                    r = (row + neighbor[0])
                    c = (col + neighbor[1])

                    # 查看相邻的细胞是否是活细胞
                    if (r < rows and r >= 0) and (c < cols and c >= 0) and abs(board[r][c]) == 1:
                        live_neighbors += 1

                # 规则 1 或规则 3 
                if board[row][col] == 1 and (live_neighbors < 2 or live_neighbors > 3):
                    # -1 代表这个细胞过去是活的现在死了
                    board[row][col] = -1
                # 规则 4
                if board[row][col] == 0 and live_neighbors == 3:
                    # 2 代表这个细胞过去是死的现在活了
                    board[row][col] = 2

        # 遍历 board 得到一次更新后的状态
        for row in range(rows):
            for col in range(cols):
                if board[row][col] > 0:
                    board[row][col] = 1
                else:
                    board[row][col] = 0

# 作者：力扣官方题解
# 链接：https://leetcode.cn/problems/game-of-life/solutions/179750/sheng-ming-you-xi-by-leetcode-solution/
# 来源：力扣（LeetCode）
# 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。