[LEETCODE][289. Game of Life][in-place方法，思想很好]

之前碰到的一题：

289. 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?

题目意思也就是总共四种判断状态：

如果本身是1，有下面三种判断：

1.相连的8个方向中1的个数刚好是2或3，下一次为1

2.相连的8个方向中1的个数>3，下一次为0

3.相连的8个方向中1的个数<2，下一次为0

如果本身是0，有下面这种判断

4.如果相连的8个方向中1的个数刚好为3，下一次为1

O(mn)的空间复杂度，O(mn)的时间复杂度这个是好想的，需要开一个二维数组存储状态

那么对于in-place的方法：

原来的状态为1或者0，是用1bit来进行存储状态的，可以拓展成2bit，在最后进行右移1位即可。那我们进行考虑8个方向的判断，因为是同时进行更新，那么根据更新原则，判断条件为count == 3 || count - board[i][j] == 3。

class Solution {
public:
    void gameOfLife(vector<vector<int>>& board) {
        int m = board.size();
        int n=board[0].size();
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
            {
                int count=0;
                for(int I=max(0,i-1);I<min(m,i+2);I++)
                    for(int J=max(0,j-1);J<min(n,j+2);J++)
                        count+=board[I][J]&1; //最低位和1与的结果
                if(count==3 || count-board[i][j]==3)//在8个方向的判断过程中包括了当前节点本身，因此是上述的判断条件
                    board[i][j]|=2; //添加成2Bit来表示
            }
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
                board[i][j]>>=1; //最终右移一位更新
    }
};

这个想法确实好，低位存之前的状态，高位存更新后的状态！！