Leetcode: NO.289 生命游戏

最新推荐文章于 2022-05-18 16:01:23 发布

泛泛之素

最新推荐文章于 2022-05-18 16:01:23 发布

阅读量206

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/tonydz0523/article/details/105278510

版权

算法专栏收录该内容

288 篇文章 2 订阅

订阅专栏

题目

链接：https://leetcode-cn.com/problems/game-of-life

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

如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
如果死细胞周围正好有三个活细胞，则该位置死细胞复活；
根据当前状态，写一个函数来计算面板上所有细胞的下一个（一次更新后的）状态。下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。

示例：

输入： 
[
  [0,1,0],
  [0,0,1],
  [1,1,1],
  [0,0,0]
]

输出：
[
  [0,0,0],
  [1,0,1],
  [0,1,1],
  [0,1,0]
]

解题思路

为了一起更新状态这个需求，简单思路就是先统计在判断，因此需要对原数据做备份，然后统计四周情况进行判断，然后更改原数据：

class Solution:
    def gameOfLife(self, board: List[List[int]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        tmp = copy.deepcopy(board)
        xmax = len(board)
        ymax = len(board[0])
        
        steps = ((-1,-1), (-1,0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1))
        
        for x in range(xmax):
            for y in range(ymax):
                live_num = 0
                for step in steps:
                    xx = x + step[0]
                    yy = y + step[1]
                    if xmax> xx >= 0 and ymax> yy >=0:
                        live_num += tmp[xx][yy]
                if tmp[x][y] == 0:
                    if live_num == 3:
                        board[x][y] = 1
                else:
                    if not 2 <= live_num <=3:
                        board[x][y] = 0

进阶

为了不做是否在边缘的判断，对数组padding处理，外围包一圈0，计算相加的时候对整体存活个数没有影响，不过内存上有所增加，空间换时间：

class Solution {
    public static void gameOfLife(int[][] board) {
        int xmax = board.length;
        int ymax = board[0].length;
        int[][] tmp = new int[xmax+2][ymax+2];

        for (int i=1; i < ymax+1; i++) {
            for (int j=1; j< xmax+1; j++){
                tmp[j][i] = board[j-1][i-1];
            }
        }

        int[][] steps = {{-1,-1}, {-1,0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};

        for (int x=1; x < ymax+1; x++) {
            for (int y=1; y< xmax+1; y++){
                int live_num = 0;
                for (int[] step: steps) {
                    int xx = x+step[0];
                    int yy = y+step[1];
                    live_num += tmp[yy][xx];
                }
                if (tmp[y][x] ==0 && live_num ==3) board[y-1][x-1] = 1;
                else if(tmp[y][x] ==1 && live_num !=2 && live_num != 3) board[y-1][x-1] = 0;
            }
        }
    }
}

kotlin写法

fun gameOfLife(board: Array<IntArray>): Unit {
    val xmax = board.size
    val ymax = board[0].size

    val tmp = Array(xmax + 2) { IntArray(ymax + 2) }

    for (i in 1 .. ymax) {
        for (j in 1 .. xmax) {
            tmp[j][i] = board[j - 1][i - 1]
        }
    }

    val steps = arrayOf(
        intArrayOf(-1, -1),
        intArrayOf(-1, 0),
        intArrayOf(-1, 1),
        intArrayOf(0, -1),
        intArrayOf(0, 1),
        intArrayOf(1, -1),
        intArrayOf(1, 0),
        intArrayOf(1, 1)
    )

    for (x in 1 .. ymax) {
        for (y in 1 .. xmax) {
            var live_num = 0
            for (step in steps) {
                val xx = x + step[0]
                val yy = y + step[1]
                live_num += tmp[yy][xx]
            }
            if (tmp[y][x] == 0 && live_num == 3) board[y - 1][x - 1] = 1
            else if (tmp[y][x] == 1 && live_num != 2 && live_num != 3) board[y - 1][x - 1] = 0
        }
    }
}