LeetCode Game of Life

原题链接在这里：https://leetcode.com/problems/game-of-life/

题目：

According to the Wikipedia's article: "The Game of Life, also known simply as Life, is a cellular automaton devised by the British mathematician John Horton Conway in 1970."

Given a board with m by n cells, each cell has an initial state live (1) or dead (0). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):

1. Any live cell with fewer than two live neighbors dies, as if caused by under-population.
2. Any live cell with two or three live neighbors lives on to the next generation.
3. Any live cell with more than three live neighbors dies, as if by over-population..
4. Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.

Write a function to compute the next state (after one update) of the board given its current state. The next state is created by applying the above rules simultaneously to every cell in the current state, where births and deaths occur simultaneously.

Example:

Input:
[
  [0,1,0],
  [0,0,1],
  [1,1,1],
  [0,0,0]
]
Output:
[
  [0,0,0],
  [1,0,1],
  [0,1,1],
  [0,1,0]
]

Follow up:

1. Could you solve it in-place? Remember that the board needs to be updated at the same time: You cannot update some cells first and then use their updated values to update other cells.
2. In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches the border of the array. How would you address these problems?

题解：

简单的想法就是copy 原来矩阵，然后根据copy 来修改原来的矩阵，如此做会使用O(m*n) space.

如何做到In-space呢，我们需要根据改动前的状态来数出live cell 的个数，已经更改的点如何知道原有的状态呢。就要多mark出几种conditions.

Dead->Dead: Condition 0;

Live->Live : Condition 1;

Live->Dead: Condition 2;

Dead->Live:Condition 3

如此在数数的时候如果该位置是1 或 2, 这个位置原有的状态都是live. 就都要算.

最后通过把所有的数%2来得到更改后的状态。

如何定义这四种状态？第一个原因是通过如此顺序是因为0本身就是dead cell, 1本身就是live cell, 如此在countLive完成后可以尽量少改动数组，如果还是live的1的状态就不用动了.

第二个原因最后对0,1,2,3改回0,1时 可以直接通过%2改动省事。

如果需要记住原有状态就可以通过增加condition 来搞定.

Time Complexity: O(m*n). Space: O(1).

AC Java:

 public class Solution {
     public void gameOfLife(int[][] board) {
         if(board == null || board.length == 0 || board[0].length == 0){
             return;
         }
         int m = board.length;
         int n = board[0].length;
         //Mark four conditions
         // Dead->Dead: 0; Live->Live : 1; Live->Dead: 2; Dead->Live:3
         for(int i = 0; i<m; i++){
             for(int j = 0; j<n; j++){
                 int count = getLive(board, i, j);   //计算周围8个位置上原来有多少个live cell
                 if(board[i][j] == 0 && count == 3){ //dead -> live
                     board[i][j] = 3;
                 }else if(board[i][j] == 1 && (count < 2 || count > 3)){ //live -> dead
                     board[i][j] = 2;
                 }
             }
         }
         //Seconde iteration, mark 2 to 0, mark 3 to 1.
         for(int i = 0; i<m; i++){
             for(int j = 0; j<n; j++){
                 board[i][j] = board[i][j]%2;
             }
         }
     }
     //计算周围8个位置上有多少个原来是live 的 细胞
     private int getLive(int [][] board, int i, int j){
         int count = 0;
         for(int x = i-1; x<=i+1; x++){
             for(int y = j-1; y<=j+1; y++){
                 if(x<0 || x>=board.length || y<0 || y>=board[0].length || (x == i && y == j)){
                     continue;
                 }
                 if(board[x][y] == 1 || board[x][y] == 2){
                     count++;
                 }
             }
         }
         return count;
     }
 }

类似Set Matrix Zeroes.