289. Game of Life

一、题目

　　1、审题

　　　　

　　2、分析

　　　　编程实现  “LIFE” 这个游戏：

　　　　　　①、若 m 的周围8个邻居细胞中存活的细胞数 < 2，则此细胞从存活状态变为死亡状态；

　　　　　　②、若 m 的周围8个邻居细胞中存活的细胞数 = 2 或 = 3，则此细胞从存活状态变为存活状态；

　　　　　　③、若 m 的周围8个邻居细胞中存活的细胞数 > 3，则此细胞从存活状态变为死亡状态；

　　　　　　③、若 m 的周围8个邻居细胞中存活的细胞数 = 3，则此细胞从死亡状态变为存活状态；　　

　　　　只能一次性更新所有的细胞的状态，不能用改变后的状态来判断后边的细胞的状态。

　　　　其中 1代表存活状态，0 代表死亡状态。

二、解答

　　1、思路

　　　方法一、

　　

　　　①、采用两个 bit 位来表示状态。刚开始，所有细胞全部是 00 或者 01；

　　　②、注意状态 1 与状态 2 是独立的。

　　　③、所有的细胞是同时从状态 1 变为状态 2的。

　　　④、计算所有细胞在未变化之前的所有邻居细胞的状态，并记录此细胞将要变化的状态2。

　　　⑤、因为状态 2 默认为 0，即死亡状态，故不需要考虑状态转变： 01 --> 00

　　　⑥、最终，通过  >> 1 向右移动一位，删除所有细胞的状态 1.

　　　⑦、每一个细胞的状态 2 的计算方法：

　　　　　　01 --> 11: 当 board == 1 并且 2 <= lives && lives <= 3;

　　　　　　00 --> 10: 当 board == 0 并且 lives == 3。

　　　⑧、获取当前的细胞的状态：  board[i][j] & 1

　　　⑨、获取细胞将要变化的状态： board[i][j] >> 1

    public void gameOfLife(int[][] board) {
        if(board == null || board.length == 0)
            return;
        int m = board.length, n = board[0].length;
        
         // In the beginning, every 2nd bit is 0;
        // So we only need to care about when will the 2nd bit become 1.
        for(int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int lives = liveNeighbors(board, m, n, i, j);
                if(board[i][j] == 1 && 2 <= lives && lives <= 3)
                    board[i][j] = 3;    // Make the 2nd bit 1: 01 ---> 11
                if(board[i][j] == 0 && lives == 3)
                    board[i][j] = 2;    // Make the 2nd bit 1: 00 ---> 10
            }
        }
        
        for(int i = 0; i < m; i++)
            for (int j = 0; j < n; j++) 
                board[i][j] >>= 1;
    }
    
    private int liveNeighbors(int[][] board, int m, int n, int i, int j) {
        int lives = 0;
        for(int x = Math.max(i - 1, 0); x <= Math.min(i + 1, m - 1); x++) {
            for (int y = Math.max(j - 1, 0); y <= Math.min(j + 1, n - 1); y++) {
                lives += board[x][y] & 1;
            }
        }
        lives -= board[i][j] & 1;
        return lives;
    }

　　方法二、

　　　　可以通过值不是 0 和 1 的两个常量记录此细胞将要变化的状态。

　　　　从而不影响统计出其他细胞的周围的存活细胞数。

　　　　最终在循环给元素赋更新的值。

    int live = 3;
    int die = 2;
    public void gameOfLife2(int[][] board) {
        if(board == null || board.length == 0)
            return;
        int rows = board.length, cols = board[0].length;
        // we only flip the 1 to die and 0 to live
        // so when we find a die around, it must be a previous 1
        // then we can count the 1s without being affected
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                int around = countLive(i, j, board);
                if(board[i][j] == 0 && around == 3)
                    board[i][j] = live;
                else if(board[i][j] == 1) {
                    if(around == 2 || around == 3)
                        continue;
                    if(around < 2 || around > 3)
                        board[i][j] = die;
                }
            }
        }
        for (int i=0;i<rows;i++){
            for (int j=0;j<cols;j++){
             if (board[i][j] == die)
                 board[i][j] = 0;
             if (board[i][j] == live)
                 board[i][j] = 1;
            }
        }
    }
    
    private int countLive(int i, int j, int[][] board) {
        int count = 0;
        int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1}};
        
        for (int[] dir:dirs){
            int x = i+dir[0];
            int y = j+dir[1];
            
            if (x>=0 && y>=0 && x < board.length && y<board[0].length ){
                
                if (board[x][y] == 1 || board[x][y] == die)
                    count ++;
            }
        }
        
        return count;
    }