Jogo da Vida (4.2leetcode diária soco)

De acordo com a Enciclopédia Baidu, Jogo da Vida, referido como a vida, é um matemático britânico John Horton Conway autômatos celulares 1,970 invenção.

Dada, uma painéis mxn de grade, cada grelha pode ser visto como uma célula. Tendo cada célula um estado inicial: 1 são as células viáveis ​​(vivas), isto é, 0, ou células mortas (mortos). Por célula de seus oito posições vizinhos (horizontal, vertical, diagonal) são os seguintes Lei sobrevivência de quatro células:

 Se o número de células viáveis de oito posições em torno de menos de duas células vivas, a localização de uma morte de células vivas;
 se oito posições em torno da célula viva tem duas ou três células vivas, a localização das células vivas ainda estavam vivos;
 se as células vivas há mais de oito posições em torno das três células vivas, o local de uma morte de células vivas;
 Se acontecer de você ter três células mortas ao redor da célula viva, a posição da ressurreição células mortas;

De acordo com o estado atual, uma função de gravação para calcular o próximo estado (após atualização) em todas as células do painel. O próximo estado é formado pelas regras acima simultaneamente aplicadas a cada célula no estado actual, em que o nascimento e a morte das células ocorre simultaneamente.

 

exemplo:

Entrada:
[
  [0,1,0],
  [0,0,1],
  [1,1,1],
  [0,0,0]
]
Output:
[
  [0,0,0],
  [0 , 1],
  [0,1,1],
  [0,1,0]
]

 

Pensando: atravessando elemento em torno de cada elemento em oito direções, é determinado, a simulação.

No entanto, esta questão podem ser aprendidas por duas matriz:  int [] = DX novo novo int [] { 0 , 0 , . 1 , - . 1 , . 1 , - . 1 , - . 1 , . 1 }; e  int [] = Dy novo novo int [] { 1. , - 1. , 0 , 0 , 1. , 1. , - 1. , - 1. }; e, em seguida, existe uma ansa de uma direcção que atravessa 8 0,  int newX = I + DX [K]; 

,  Int newY J = Dy + [K]; esta passagem de oito direcções.

Um  vazio gameOfLife ( int ** placa, int boardSize, int * boardColSize) {
 2      se (boardColSize [ 0 ] == 0 )
 3          de retorno ;
4      int um [boardSize] [boardColSize [ 0 ]];
5      int dir [ 8 ] [ 2 ] = {{ 1 , 0 }, { 0 , 1 }, {- 1 , 0 }, { 0 , - 1 }, {- 1 , - 1}, { 1 , 1 }, {- 1 , 1 }, { 1 , - 1 }};
6      int i = 0 , j = 0 , z;
7      para (i = 0 ; i <boardSize; i ++ )
 8      {
 9          para (j = 0 ; j <boardColSize [ 0 ]; j ++ )
 10          {
 11              um [i] [j] = 0 ;
12          }
 13      }
 14  
15  
16      para(i = 0 ; i <boardSize; i ++ )
 17      {
 18          para (j = 0 ; j <boardColSize [i]; j ++ )
 19          {
 20              int k = 0 ;
21              para (z = 0 ; Z < 8 ; z ++ )
 22              {
 23                  int x = i + dir [z] [ 0 ];
24                  int y = j + dir [z] [ 1 ];
25                  , se (x < 0 || y < 0 || x> = boardSize || y> = boardColSize [0 ])
 26                  {
 27                      continuar ;
28                  }
 29                  se (placa [x] [y] == 1 )
 30                      k ++ ;
31              }
 32              , se (k < 2 )
 33                  a [i] [j] = 0 ;
34              se (placa de [i] [j] == 1 && k> = 2 && k <= 3 )
 35                  um [i] [j] = 1 ;
36              se (placa de [i] [j] == 1&& k> 3 )
 37                  um [i] [j] = 0 ;
38              , se (k == 3 )
 39                  um [i] [j] = 1 ;
40          }
 41      }
 42      para (i = 0 ; i <boardSize; i ++ )
 43      {
 44          para (j = 0 ; j <boardColSize [ 0 ]; j ++ )
 45          {
 46              bordo [i] [j] = uma [i] [j];
47          }
 48      }
49 }