Contando ilhas em matrizes booleanas

Dada uma matriz booleana X , deixe entradas representam o mar e entradas representam terra. Defina uma ilha como vertical ou horizontalmente (mas não na diagonal) entradas adjacentes .$n \times m$$\mathrm X$1 $0$$1$$1$

A questão original era contar o número de ilhas em uma determinada matriz. O autor descreveu uma solução recursiva ( memória ).$\mathcal{O}(nm)$

Mas eu estava tentando, sem êxito, encontrar uma solução de streaming (da esquerda para a direita e depois para a próxima linha) que conta dinamicamente ilhas com ou O ( n ) ou O ( n + m ) de memória ( não há limites para a complexidade do tempo). Isso é possível? Caso contrário, como posso provar isso?$\mathcal{O}(m)$$\mathcal{O}(n)$$\mathcal{O}(n+m)$

Alguns exemplos de saídas esperadas para determinadas entradas da countfunção:

$count\begin{pmatrix} 010\\ 111\\ 010\\ \end{pmatrix} = 1; % count\begin{pmatrix} 101\\ 010\\ 101\\ \end{pmatrix} = 5; % count\begin{pmatrix} 111\\ 101\\ 111\\ \end{pmatrix} = 1;$

$count\begin{pmatrix} 1111100\\ 1000101\\ 1010001\\ 1011111\\ \end{pmatrix} = 2$

$count\begin{pmatrix} 101\\ 111\\ \end{pmatrix} = 1$

Aqui está um esboço de um algoritmo que mantém apenas duas linhas na memória por vez, então memória. Mas como você pode executar esse algoritmo na transposição da matriz sem problemas, a complexidade real é a memória O ( min ( m , n ) ) . O tempo de processamento é O ( m n ) .$O(m)$$O(\min(m, n))$$O(mn)$

1. Inicialização. Digitalize sobre a primeira linha e encontre todas as substrings conectadas dessa linha. Atribua a cada substring separado um ID positivo único e salve-o como um vetor que é zero, onde é zero e o ID positivo exclusivo, caso contrário.$X$

2. Para cada linha restante, atribua IDs únicos (nunca reatribua IDs anteriores anteriores, verifique se os seus IDs estão aumentando estritamente) a substrings nessa linha novamente. Veja a linha anterior mais a linha atual como uma matriz de por m , e todas as áreas conectadas devem ser atribuídas ao mínimo. Como um exemplo:$2$$m$

   $$\begin{array}0010402220333300\\ 506607080009990\end{array} \rightarrow \begin{array}0010402220333300\\ 504402020003330\end{array}$$

   Não há necessidade de atualizar a linha anterior para a correção desse algoritmo, apenas o atual.

   Depois disso, encontre o conjunto de todos os IDs na linha anterior que não se conectam à próxima linha, descartando duplicatas . Adicione o tamanho desse conjunto ao seu contador de ilhas em execução.

   Agora você pode descartar a linha anterior e atribuir a linha atual à linha anterior e seguir em frente.

3. Para manipular corretamente a última linha, finja que há outra linha de zeros na parte inferior do e execute a etapa 2 novamente.$X$

Orlp fornece uma solução usando palavras de espaço, que são O ( n log n ) bits de espaço (assumindo por simplicidade que$O(n)$$O(n\log n)$ ). Por outro lado, é fácil mostrar que Ω ( n ) bits de espaço são necessários, reduzindo a disjunção definida para o seu problema.$n=m$$\Omega(n)$

$x_1,\ldots,x_n$$y_1,\ldots,y_n$$i$$x_i=y_i=1$$2\times(2n-1)$$x_1,0,x_2,0,\ldots,0,x_n$$y_1,0,y_2,0,\ldots,0,y_n$$\sum_i x_i$$\sum_i (x_i+y_i)$$i$$\Omega(n)$$\Omega(n)$

$O(n)$$O(\log n)$$O(n)$