生命游戏-----算法题，思路讲解和优化。

题目：

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

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

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

下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。给你?m x n?网格面板?board?的当前状态，返回下一个状态。

解题思路一：copy一个数组。

????????

 public void gameOfLife(int[][] board) {
        int[] neighbors ={0,1,-1};
        int rows = board.length;
        int cols = board[0].length;

        int[][] copyboard =new int[rows][cols];
        /// 从原数组复制一份到 copyBoard 中
        for (int row=0;row <rows;row++){
            for (int col =0;col <cols;col++){
                copyboard[row][col] =board[row][col];
            }
        }
        //
        for (int row=0;row <rows;row++){
            for (int col =0;col <cols;col++){
                // 对于每一个细胞统计其八个相邻位置里的活细胞数量
               int live =0;
               for (int i=0;i <3;i++){
                   for (int j=0;j <3;j++){
                       //这个条件语句的目的是排除掉 (0, 0)，因为 (0, 0) 表示当前细胞本身
                       // ，而在统计相邻活细胞数量时，我们只关心周围的八个相邻位置。
                       if (!(neighbors[i]==0&&neighbors[j]==0)){
                           //其中 row 和 col 分别是当前细胞的行索引和列索引。
                           int r =(row+neighbors[i]);
                           int c =col+neighbors[j];
                           //(r < rows && r >= 0) 和 (c < cols && c >= 0) 用于确保相邻位置在矩阵范围内。
                           //(copyBoard[r][c] == 1) 用于检查相邻位置是否为活细胞，如果是，则增加 liveNeighbors 计数。
                           if ((r >=0 && r<rows) &&(c <cols && c>=0) &&(copyboard[r][c]==1)){
                               live+=1;
                           }
                       }
                   }
               }

               // // 规则 1 或规则 3
               if ((copyboard[row][col] ==1) &&(live<2 || live >3)){
                   board[row][col] =0;
               }

               if (copyboard[row][col] ==0 && live ==3){
                   board[row][col] =1;
               }
            }
        }
    }

特别讲解一下?neighbors 数组和相应的循环：

neighbors 数组包含了一个细胞的八个相邻位置，其值为 (0, 1, -1)。这表示对于一个细胞 (i, j)，它的八个相邻位置分别是：

(i-1, j-1)  (i-1, j)  (i-1, j+1)
(i, j-1)    (i, j)    (i, j+1)
(i+1, j-1)  (i+1, j)  (i+1, j+1)

这样，neighbors 数组中的每一对值 (x, y) 表示相对于当前细胞的偏移量。

解法二：状态记录，减少空间复杂度

? ? ? ?

根据数组的细胞状态计算新一轮的细胞状态，这里会用到能同时代表过去状态和现在状态的复合状态。

具体的计算规则如下所示：

规则 1：如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡。这时候，将细胞值改为 -1，代表这个细胞过去是活的现在死了；

规则 2：如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活。这时候不改变细胞的值，仍为 1；

规则 3：如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡。这时候，将细胞的值改为 -1，代表这个细胞过去是活的现在死了。可以看到，因为规则 1 和规则 3 下细胞的起始终止状态是一致的，因此它们的复合状态也一致；

规则 4：如果死细胞周围正好有三个活细胞，则该位置死细胞复活。这时候，将细胞的值改为 2，代表这个细胞过去是死的现在活了。

根据新的规则更新数组；

现在复合状态隐含了过去细胞的状态，所以我们可以在不复制数组的情况下完成原地更新；

对于最终的输出，需要将 board 转成 0，1 的形式。因此这时候需要再遍历一次数组，将复合状态为 2 的细胞的值改为 1，复合状态为 -1 的细胞的值改为 0。

public void gameOfLife2(int[][] board) {
        //使用额外的状态
        int[] neighbors = {0, 1, -1};

        int rows = board.length;
        int cols = board[0].length;

        // 遍历面板每一个格子里的细胞
        for (int row = 0; row < rows; row++) {
            for (int col = 0; col < cols; col++) {
                int live =0;

                for (int i=0;i <3;i++){
                    for (int j=0;j <3;j++){
                        //这个条件语句的目的是排除掉 (0, 0)，因为 (0, 0) 表示当前细胞本身
                        // ，而在统计相邻活细胞数量时，我们只关心周围的八个相邻位置。
                        if (!(neighbors[i]==0&&neighbors[j]==0)){
                            //其中 row 和 col 分别是当前细胞的行索引和列索引。
                            int r =(row+neighbors[i]);
                            int c =col+neighbors[j];
                            //(r < rows && r >= 0) 和 (c < cols && c >= 0) 用于确保相邻位置在矩阵范围内。
                            //使用 Math.abs 方法取相邻位置的细胞值的绝对值，判断是否为活细胞。这里之所以取绝对值，是因为在康威生命游戏中，通常用 1 表示活细胞，-1 表示之前是活细胞
                            // ，但在当前阶段已经死亡。所以取绝对值后，判断是否为 1，即为活细胞。
                            if ((r >=0 && r<rows) &&(c <cols && c>=0) &&(Math.abs(board[r][c])==1)){
                                live+=1;
                            }
                        }
                    }
                }

                // 规则 1 或规则 3
                if ((board[row][col] == 1) && (live < 2 || live > 3)) {
                    // -1 代表这个细胞过去是活的现在死了
                    board[row][col] = -1;
                }
                // 规则 4
                if (board[row][col] == 0 && live == 3) {
                    // 2 代表这个细胞过去是死的现在活了
                    board[row][col] = 2;
                }

            }
        }

        // 遍历 board 得到一次更新后的状态
        for (int row = 0; row < rows; row++) {
            for (int col = 0; col < cols; col++) {
                if (board[row][col] > 0) {
                    board[row][col] = 1;
                } else {
                    board[row][col] = 0;
                }
            }
        }

    }