📌  相关文章
📜  康威的生命游戏计划| 2套

📅  最后修改于: 2021-09-04 09:33:48             🧑  作者: Mango

给定一个大小为N*M的二进制grid[ ][ ] ，每个单元格包含 0 或 1，其中 1 代表一个活细胞，0 代表一个死细胞。任务是根据以下规则生成下一代细胞：

  1. 由于人口不足，任何具有少于两个活邻居的活细胞都会死亡。
  2. 任何有两个或三个活邻居的活细胞都会传给下一代。
  3. 任何拥有三个以上活邻居的活细胞都会因人口过剩而死亡。
  4. 任何只有三个活邻居的死细胞通过繁殖成为活细胞。

这里，一个单元格的邻居包括它的相邻单元格以及对角线单元格，因此对于每个单元格，总共有8 个邻居。
例子：

天真的方法：
我们已经在 Program for Conway’s Game Of Life | 中讨论了解决这个问题的方法。 Set 1. 在这种方法中，创建了一个额外的大小为N*M 的网格future[ ][ ]来存储下一代单元格。
时间复杂度： O(N*M)
辅助空间： O(N*M)
有效的方法：
对于这个问题，空间优化的方法是可能的，它不使用额外的空间。对于每个活着的单元格，每次遇到一个活着的邻居时，将其值增加 1。并且，对于每个死细胞，每次我们遇到一个活着的邻居时，将其值减 1。现在，如果单元格中的值小于0，则表示它是死单元格，如果值大于0，则表示它是活单元格，单元格中值的大小也将代表其存活的数量邻居。这样，就不需要额外的网格，并获得空间优化的解决方案。该方法的详细步骤如下：
对于当前的网格位置，我们将查看所有邻居。

  1. 遍历整个网格。
  2. 如果邻居的值>= 1 (即邻居的初始值为1)
    • 如果当前小区是> = 1，仅通过1递增当前小区的值。
      现在， grid [ i ][ j ] > 0 将意味着初始 grid [ i ][ j ] == 1。
    • 否则，当前单元格<= 0 ，只需将当前单元格值减1。
      现在， grid [ i ][ j ] <= 0 将意味着初始 grid [ i ][ j ] == 0。
  3. 现在，使用修改后的网格生成所需的新一代网格。
    • 如果当前单元格值> 0 ，则有 3 种可能的情况：
      • 如果该值 < 3，则将其更改为 0。
      • 否则，如果值 <= 4，则将其更改为 1。
      • 否则将值更改为 0。
    • 否则，当前单元格值为<= 0 。
      • 如果值为 3，则将其更改为 1。
      • 否则将其更改为 0。

下面是上述方法的实现：

C++
// C++ implementation of
// the above approach
 
#include
using namespace std;
 
class GameOfLife {
public:
    // Function to display the grid
    void print(vector grid);
 
    // Function to check if
    // index are not out of grid
    bool save(vector grid,
              int row, int col);
 
    // Function to get New Generation
    void solve(vector& grid);
};
 
void GameOfLife::print(
    vector grid)
{
    int p = grid.size(),
        q = grid[0].size();
 
    for (int i = 0; i < p; i++) {
        for (int j = 0; j < q; j++) {
 
            cout << grid[i][j];
        }
        cout << endl;
    }
}
 
bool GameOfLife::save(
    vector grid,
    int row, int col)
{
    return (grid.size() > row
            && grid[0].size() > col
            && row >= 0
            && col >= 0);
}
 
// Possible neighboring indexes
int u[] = { 1, -1, 0, 1, -1, 0, 1, -1 };
int v[] = { 0, 0, -1, -1, -1, 1, 1, 1 };
 
void GameOfLife::solve(
    vector& grid)
{
    int p = grid.size(),
        q = grid[0].size();
 
    for (int i = 0; i < p; i++) {
        for (int j = 0; j

Java
// Java program for
// the above approach
import java.util.*;
import java.lang.*;
class GFG{
   
static void print(int[][] grid)
{
  int p = grid.length,
  q = grid[0].length;
 
  for (int i = 0; i < p; i++)
  {
    for (int j = 0; j < q; j++)
    {
      System.out.print(grid[i][j]);
    }
    System.out.println();;
  }
}
 
static boolean save(int[][] grid,
                    int row, int col)
{
  return (grid.length > row &&
          grid[0].length > col &&
          row >= 0 && col >= 0);
}
 
static void solve(int[][] grid)
{
  int p = grid.length,
  q = grid[0].length;
 
  // Possible neighboring
  // indexes
  int u[] = {1, -1, 0, 1,
             -1, 0, 1, -1};
  int v[] = {0, 0, -1, -1,
             -1, 1, 1, 1};
   
  for (int i = 0; i < p; i++)
  {
    for (int j = 0; j < q; j++)
    {
      // IF the initial value
      // of the grid(i, j) is 1
      if (grid[i][j] > 0)
      {
        for (int k = 0; k < 8; k++)
        {
          if (save(grid, i + u[k],
                   j + v[k]) &&
                   grid[i + u[k]][j + v[k]] > 0)
          {
            // If initial value > 0,
            // just increment it by 1
            grid[i][j]++;
          }
        }
      }
 
      // IF the initial value
      // of the grid(i, j) is 0
      else
      {
        for (int k = 0; k < 8; k++)
        {
          if (save(grid, i + u[k],
                   j + v[k]) &&
                   grid[i + u[k]][j + v[k]] > 0)
          {
            // If initial value <= 0
            // just decrement it by 1
            grid[i][j]--;
          }
        }
      }
    }
  }
 
  // Generating new Generation.
  // Now the magnitude of the
  // grid will represent number
  // of neighbours
  for (int i = 0; i < p; i++)
  {
    for (int j = 0; j < q; j++)
    {
      // If initial value was 1.
      if (grid[i][j] > 0)
      {
        // Since Any live cell with
        // < 2 live neighbors dies
        if (grid[i][j] < 3)
          grid[i][j] = 0;
 
        // Since Any live cell with
        // 2 or 3 live neighbors live
        else if (grid[i][j] <= 4)
          grid[i][j] = 1;
 
        // Since Any live cell with
        // > 3 live neighbors dies
        else if (grid[i][j] > 4)
          grid[i][j] = 0;
      }
      else
      {
        // Since Any dead cell with
        // exactly 3 live neighbors
        // becomes a live cell
        if (grid[i][j] == -3)
          grid[i][j] = 1;
        else
          grid[i][j] = 0;
      }
    }
  }
}
 
// Driver code
public static void main (String[] args)
{
  int[][] grid = {{0, 0, 0, 0, 0,
                   0, 0, 0, 0, 0},
                  {0, 0, 0, 1, 1,
                   0,0, 0, 0, 0},
                  {0, 0, 0, 0, 1,
                   0, 0, 0, 0, 0},
                  {0, 0, 0, 0, 0,
                   0, 0, 0, 0, 0},
                  {0, 0, 0, 0, 0,
                   0, 0, 0, 0, 0}};
   
  // Function to generate
  // New Generation inplace
  solve(grid);
 
  // Displaying the grid
  print(grid);
}
}
 
// This code is contributed by offbeat

输出： 
0000000000
0001100000
0001100000
0000000000
0000000000

时间复杂度： O(N*M)
辅助空间： O(1)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live