leetCode-289. 生命游戏

题目：

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

给定一个包含 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 {

    //因为面板上所有格子需要同时被更新：不能先更新某些格子，然后使用它们的更新后的值再更新其他格子
    //所以先用一个数组复制原始数组，然后更新规则基于该数组即可

    //八个相邻位置（水平，垂直，对角线）
    int[] dx = {-1, 1, 0, 0, -1, -1, 1, 1};
    int[] dy = {0, 0, -1, 1, -1, 1, -1, 1};
    public void gameOfLife(int[][] board) {
        int rows = board.length;
        int cols = board[0].length;
         
         int[][] copy = new int[rows][cols];
          for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
               copy[i][j] = board[i][j];
            }
        }

        for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
                int count = countLife(copy,i,j,rows,cols);
                //生存定律1
                if(copy[i][j] == 1 && count < 2){
                    board[i][j] = 0;
                }
                //生存定律3
                if(copy[i][j] == 1 && count > 3){
                    board[i][j] = 0;
                }
                //生存定律4
                if(copy[i][j] == 0 && count == 3){
                    board[i][j] = 1;
                }
            }
        }

    }

    //统计当前细胞八个位置的活细胞数
    public int countLife(int[][] copy,int x,int y,int rows,int cols){
        int tx = 0,ty = 0;
        int count = 0;
        for(int k=0;k<8;k++){
            tx = x + dx[k];
            ty = y + dy[k];

            if( tx>=0&&tx<rows && ty>=0&&ty<cols && copy[tx][ty] == 1){
                ++count;
            }
        }
        return count;
    }
}

复杂度分析

• 时间复杂度：O(mn)，其中 m和 n 分别为 board 的行数和列数。
• 空间复杂度：O(mn)，为复制数组占用的空间。

解题思路【优化空间复杂度】：

因为面板上所有格子需要同时被更新：不能先更新某些格子，然后使用它们的更新后的值再更新其他格子

    为了进一步降低空间复杂度，不用复制数组，而是通过状态标记细胞的生命的变化：

    -1：原来是活细胞，更新后死亡;

    0：原来是死细胞，更新后仍死亡;

    1：原来是活细胞，更新后仍存活;

    2：原来是死细胞，更新后仍死亡;

    根据状态和更新规则来更新每个细胞即可

代码实现：

class Solution {

    //八个相邻位置（水平，垂直，对角线）
    int[] dx = {-1, 1, 0, 0, -1, -1, 1, 1};
    int[] dy = {0, 0, -1, 1, -1, 1, -1, 1};
    public void gameOfLife(int[][] board) {
        int rows = board.length;
        int cols = board[0].length;

        for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
                int count = countLife(board,i,j,rows,cols);
                //生存定律1
                if(board[i][j] == 1 && count < 2){
                    board[i][j] = -1;
                }
                //生存定律3
                if(board[i][j] == 1 && count > 3){
                    board[i][j] = -1;
                }
                //生存定律4
                if(board[i][j] == 0 && count == 3){
                    board[i][j] = 2;
                }
            }
        }

        //遍历得到更新状态
        for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
               board[i][j] = board[i][j]>0?1:0;
            }
        }
    }

    //统计当前细胞八个位置的活细胞数
    public int countLife(int[][] board,int x,int y,int rows,int cols){
        int tx = 0,ty = 0;
        int count = 0;
        for(int k=0;k<8;k++){
            tx = x + dx[k];
            ty = y + dy[k];

            if( tx>=0&&tx<rows && ty>=0&&ty<cols && (board[tx][ty] == 1 || board[tx][ty] == -1)){
                ++count;
            }
        }
        return count;
    }
}

 复杂度分析

• 时间复杂度：O(mn)，其中 m，n 分别为 board 的行数和列数。
• 空间复杂度：O(1)，除原数组外只需要常数的空间存放若干变量。