题目描述

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

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

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

根据当前状态,写一个函数来计算面板上细胞的下一个(一次更新后的)状态。下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的,其中细胞的出生和死亡是同时发生的。

示例:

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

进阶:

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

解法1

这道题本身没什么难度,类似于迭代算法,利用i-1轮的输出作为第i轮第输入,但是题目只要求一次更新后的状态,那么我们再开辟一个数组ans[m][n]存储第i轮第状态。因为题目说了不能先更新某些格子,再使用它们更新其他格子。

题目要求8个方向,我们可以定义数组dirI={-1,-1,-1,1,1,1,0,0}与dirJ={-1,0,1,-1,0,1,-1,1},这样可以方便的利用dirI与dirJ将当前坐标(i,j)变换为(i+dirI[k], j+dirJ[k]), 0 <=k<8,来计算8个方向第坐标。

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

另外需要理清下逻辑,虽然题目给了4个规则,但是他们可以化简成两条:

  1. 如果细胞周围有三个活细胞,则该位置的细胞下一次更新存活(无论当前细胞是死是活)
  2. 如果活细胞周围有两个活细胞,则该位置的细胞下一次仍存活

全部代码如下,时间复杂度O(m*n),空间复杂度O(m*n)。

class Solution {
    public void gameOfLife(int[][] board) {
        if(board == null || board.length == 0) return;
        int[][] ans = new int[board.length][board[0].length];
        int[] dirI = new int[]{-1,-1,-1,1,1,1,0,0};
        int[] dirJ = new int[]{-1,0,1, -1,0,1,-1,1};
        
        
        for(int i=0;i<board.length;i++) {
            for(int j=0;j<board[0].length;j++) {
                int live = 0;
                for(int k =0 ;k<8;k++){
                    int nbrI = i+dirI[k];
                    int nbrJ = j+dirJ[k];
                    
                    if(nbrI>=0 && nbrI<board.length && nbrJ>=0 && nbrJ<board[0].length){
                        if(board[nbrI][nbrJ]==1)
                            live++;
                    }
                }
                if(board[i][j] == 1 && live == 2 || live == 3)
                    ans[i][j] = 1;
            }
        }
        
      
        for(int i=0;i<board.length;i++) {
            for(int j=0;j<board[0].length;j++) {
                board[i][j] = ans[i][j];
            }
        }
    }
}

解法1优化

题目给了进阶要求,可以使用原地算法吗?矩阵board只用了0,1来表示该位置细胞的死活,但却用int型存储,这就浪费了31 bits。我们可以利用32bits中的第2位来表示下一次细胞的死活,这样就能够实现原地算法。

我们先复习下常用的位操作。

  1. 检查某一位是0还是1
  2. 将某一位置0
  3. 将某一位置1

检查第i位是0还是1,我们只需要将1左移(<<)i次,然后对数字做与(&)操作。将第i位置1,只需将1左移(<<)i次,然后对数字做或(|)操作。对第i位置零,我们先将1左移(<<)i次,然后取反(~),再对数字做与(&)操作。

这道题只涉及到位检查操作与置1操作,当board数组更新完毕后,第2位就是下一次细胞的状态,我们将board[i][j]右移(>>)1位就是答案。全部代码如下,时间复杂度O(m*n),空间复杂度O(1)。

class Solution {
    public void gameOfLife(int[][] board) {
        if(board == null || board.length == 0) return;
        int[] dirI = new int[]{-1,-1,-1,1,1,1,0,0};
        int[] dirJ = new int[]{-1,0,1,-1,0,1,-1,1};
        
        
        for(int i=0;i<board.length;i++) {
            for(int j=0;j<board[0].length;j++) {
                int live = 0;
                
                for(int k =0 ;k<8;k++){
                    int nbrI = i+dirI[k];
                    int nbrJ = j+dirJ[k];
                    
                    if(nbrI>=0 && nbrI<board.length && nbrJ>=0 && nbrJ<board[0].length){
                        if((board[nbrI][nbrJ] & 1) == 1)
                            live++;
                    }
                }
                
                if(board[i][j] == 1 && live == 2 || live == 3)
                    board[i][j] |= (1 << 1);
            }
        }
        
      
        for(int i=0;i<board.length;i++) {
            for(int j=0;j<board[0].length;j++) {
                board[i][j] >>= 1;
            }
        }
    }
}
pwrliang Algorithms, Array, Bit-Operation

Leave a Reply

Your email address will not be published. Required fields are marked *