LeetCode Game of Life

Description:

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):

Any live cell with fewer than two live neighbors dies, as if caused by under-population.
Any live cell with two or three live neighbors lives on to the next generation.
Any live cell with more than three live neighbors dies, as if by over-population..
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.
Solution 1:

First it is very easy so think out of a method not using in-place.

Just do this as the problem asked.

<span style="font-size:18px;">public class Solution {
int dir[][] = new int[][] { { 0, 1, 0, -1, 1, 1, -1, -1 },
{ 1, 0, -1, 0, 1, -1, 1, -1 } };

public boolean valid(int i, int j, int m, int n) {
if (i < 0 || i >= m)
return false;
if (j < 0 || j >= n)
return false;
return true;
}

public void gameOfLife(int[][] board) {
int m = board.length;
int n = board[0].length;

int map[][] = new int[m]
;

int neoI, neoJ;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int count = 0;
for (int k = 0; k < 8; k++) {
neoI = i + dir[0][k];
neoJ = j + dir[1][k];
if (valid(neoI, neoJ, m, n)) {
if (board[neoI][neoJ] == 1)
count++;
}
}
if (count < 2)
map[i][j] = 0;
else if (count > 3)
map[i][j] = 0;
else if (count == 3)
map[i][j] = 1;
else
map[i][j] = board[i][j];
}
}

for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
board[i][j] = map[i][j];

}
}</span>

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.

To implement the in-place, we can encode the 4 different situations. For example:

0 : 0 - 0

1: 1 - 1

2: 0 - 1

3: 1 - 0

public class Solution {
int dir[][] = new int[][] { { 0, 1, 0, -1, 1, 1, -1, -1 },
{ 1, 0, -1, 0, 1, -1, 1, -1 } };

public boolean valid(int i, int j, int m, int n) {
if (i < 0 || i >= m)
return false;
if (j < 0 || j >= n)
return false;
return true;
}

public void gameOfLife(int[][] board) {
int m = board.length;
int n = board[0].length;

int neoI, neoJ;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int count = 0;
for (int k = 0; k < 8; k++) {
neoI = i + dir[0][k];
neoJ = j + dir[1][k];
if (valid(neoI, neoJ, m, n)) {
if (board[neoI][neoJ] == 1 || board[neoI][neoJ] == 3)
count++;
}
}
if (board[i][j] == 0 && count == 3)
board[i][j] = 2;
if (board[i][j] == 1 && (count != 2 && count != 3))
board[i][j] = 3;
}
}

for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
if (board[i][j] == 2)
board[i][j] = 1;
else if (board[i][j] == 3)
board[i][j] = 0;

}
}

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?

We can try to only record the positions that are alive.