Cepille LeetCode desde cero: el número de islas

Titulo:

  Proporcione una cuadrícula bidimensional compuesta de '1' (tierra) y '0' (agua), cuente el número de islas en la cuadrícula. Las islas siempre están rodeadas de agua, y cada isla solo puede estar formada por conexiones terrestres adyacentes horizontales y / o verticales. Además, puede suponer que los cuatro lados de la cuadrícula están rodeados de agua.

Ejemplos:

Ingrese:

         11110

         11010

         11000

         00000

Salida: 1

Fuente: LeetCode

 

Método 1: búsqueda profunda

  Este problema puede considerarse como un problema para encontrar el valor del vecino más cercano. En una cuadrícula, los vecinos más cercanos definidos aquí son arriba, abajo, izquierda y derecha. Luego podemos atravesar la profundidad de la misma manera que el árbol binario, suponiendo que sea equivalente a un "árbol cuádruple". Pero de esta manera, habrá repeticiones durante el proceso transversal, por lo que establecemos todos los '1' encontrados en '0' durante el proceso de búsqueda profunda, para que podamos evitar repeticiones.

1  # 深度 搜索
2  clase Solución (objeto):
 3      def numIslands (self, grid):
 4          nums = 0
 5          para i in range (len (grid)):
 6              for j in range (len (grid [0])) :
 7                  if grid [i] [j] == ' 1 ' :
 8                      self.search_depth (grid, i, j)
 9                      nums + = 1
 10          return nums
 11  
12      def search_depth (self, grid, x, y):
 13          Six> = len (grilla) o y> = len (grilla [0]) o x <0 o y < 0:
 14              devuelve  
15          
16          si grilla [x] [y] == ' 1 ' :
 17              grilla [x] [y] = ' 0 ' 
18              self.search_depth (grid, x-1 , y)
 19              self.search_depth (grid, x, y-1 )
 20              self.search_depth (grid, x + 1 , y)
 21              self.search_depth (cuadrícula, x, y + 1 )

 

 Método 2: búsqueda de amplitud

  Puede resolverse mediante una búsqueda profunda, pero el proceso recursivo ocupará mucha memoria, por lo que podemos reemplazar el proceso recursivo con una lista. Cuando atravesamos un punto, él es '1' y se convierte en un punto de isla, por lo que agregamos sus puntos de isla vecinos, es decir, los puntos de '1' arriba, abajo, izquierda y derecha, a una lista, y luego continuamente de la lista Saque el punto de la isla como el punto central de la isla y agregue las islas vecinas a la lista nuevamente, hasta que la lista esté vacía, el cálculo esté completo. Esto reemplaza todo el proceso recursivo con una lista.

1  # 广度 搜索
Clase 2  Solución (objeto):
 3 def numIslands (self, grid):
 4          nr = len (grid)
 5 si nr == 0:
 6 devuelve 0
 7          nc = len (grid [0])
 8          num_islands = 0
 9 para r en rango (nr):
 10 para c en rango (nc):
 11 si grilla [r] [c] == " 1 " :
 12                      num_islands + = 1
                                                                  13                      cuadrícula [r] [c] = " 0 " 
14                      vecinos = colecciones.deque ([(r, c)])
 15                      mientras vecinos:
 16                          fila, col = vecinos.popleft ()
 17                          para x, y en [(fila - 1, col), (fila + 1, col), (fila, col - 1), (fila, col + 1 )]:
 18                              si 0 <= x <nr y 0 <= y <nc y grilla [x ] [y] == " 1 " :
 19                                  vecinos. Apéndice ((x, y))
 20                                 grid [x] [y] = " 0 " 
21          return num_islands

 

Supongo que te gusta

Origin www.cnblogs.com/fsencen/p/leetcode2.html
Recomendado
Clasificación