freeCodeCamp/guide/portuguese/algorithms/flood-fill/index.md

100 lines
3.5 KiB
Markdown
Raw Normal View History

---
title: Flood Fill Algorithm
localeTitle: Algoritmo de preenchimento de inundações
---
## Algoritmo de preenchimento de inundações
O preenchimento de inundação é um algoritmo usado principalmente para determinar uma área limitada conectada a um determinado nó em uma matriz multidimensional. Isto é uma grande semelhança com a ferramenta balde em programas de pintura.
A implementação mais aproximada do algoritmo é uma função recursiva baseada em pilha, e é sobre isso que vamos falar Próximo.
### Como funciona?
O problema é bastante simples e geralmente segue estas etapas:
1. Tome a posição do ponto de partida.
2. Decida se deseja ir em 4 direções ( **N, S, W, E** ) ou 8 direções ( **N, S, W, E, NW, NE, SW, SE** ).
3. Escolha uma cor de substituição e uma cor de destino.
4. Viaje nessas direções.
5. Se o piso em que você pousar for um alvo, reaplique-o com a cor escolhida.
6. Repita 4 e 5 até que você esteja em todos os lugares dentro dos limites.
Vamos pegar o seguinte array como exemplo:
![texto alternativo](https://github.com/firealex2/Codingame/blob/master/small%208%20grid%20paintefffd.png)
O quadrado vermelho é o ponto de partida e os quadrados cinzentos são as chamadas paredes.
Para mais detalhes, aqui está um trecho de código descrevendo a função:
```c++
int wall = -1;
void flood_fill(int pos_x, int pos_y, int target_color, int color)
{
if(a[pos_x][pos_y] == wall || a[pos_x][pos_y] == color) // if there is no wall or if i haven't been there
return; // already go back
if(a[pos_x][pos_y] != target_color) // if it's not color go back
return;
a[pos_x][pos_y] = color; // mark the point so that I know if I passed through it.
flood_fill(pos_x + 1, pos_y, color); // then i can either go south
flood_fill(pos_x - 1, pos_y, color); // or north
flood_fill(pos_x, pos_y + 1, color); // or east
flood_fill(pos_x, pos_y - 1, color); // or west
return;
}
```
Como visto acima, meu ponto de partida é (4,4). Depois de chamar a função para as coordenadas iniciais **x = 4** e **y = 4** , Eu posso começar a verificar se não há parede ou cor no local. Se isso for válido, marquei o ponto com uma **"cor"** e comece a verificar os outros quadrados adjacentes.
Indo para o sul, chegaremos ao ponto (5,4) e a função será executada novamente.
### Problema de exercício
Eu sempre considerei que resolver um (ou mais) problema / s usando um novo algoritmo aprendido é a melhor maneira de entender completamente o conceito.
Então aqui está um:
**Declaração:**
Em uma matriz bidimensional, você recebe um número de **"ilhas"** . Tente encontrar a maior área de uma ilha e o número da ilha correspondente. 0 marca a água e qualquer outro x entre 1 e n marca um quadrado da superfície correspondente para ilha x.
**Entrada**
* **n** - o número de ilhas.
* **l, c** - as dimensões da matriz.
* as próximas linhas **l** , números **c** que dão a linha **l** da matriz.
**Saída**
* **i** - o número da ilha com a maior área.
* **A** - a área do **i** 'th ilha.
**Ex:**
Você tem a seguinte entrada:
```c++
2 4 4
0 0 0 1
0 0 1 1
0 0 0 2
2 2 2 2
```
Para o qual você terá ilha não. 2 como a maior ilha com a área de 5 praças.
### Dicas
O problema é bem fácil, mas aqui estão algumas dicas:
```
1. Use the flood-fill algorithm whenever you encounter a new island.
2. As opposed to the sample code, you should go through the area of the island and not on the ocean (0 tiles).
```