Conteggio delle isole in matrici booleane

Data una matrice booleana , lascia che voci rappresentino il mare e voci rappresentino la terra. Definire un'isola come adiacente verticalmente o orizzontalmente (ma non in diagonale) .$n \times m$$\mathrm X$$0$$1$$1$

La domanda originale era di contare il numero di isole in una data matrice. L'autore ha descritto una soluzione ricorsiva ( memoria ).$\mathcal{O}(nm)$

Ma stavo tentando senza successo di trovare una soluzione di streaming (da sinistra a destra, quindi fino alla riga successiva) che conteggi dinamicamente le isole con o o memoria (non ci sono limiti per la complessità temporale). È possibile? In caso contrario, come posso provarlo?$\mathcal{O}(m)$$\mathcal{O}(n)$$\mathcal{O}(n+m)$

Alcuni esempi di uscite previste per determinati ingressi per la countfunzione:

$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$

$O(m)$ memoria. Il tempo di elaborazione è O ( m n ) .$O(\min(m, n))$$O(mn)$

1. Inizializzazione. Scansione sopra la prima riga e trova tutte le sottostringhe connesse di quella riga. Assegna a ogni sottostringa disgiunta un ID positivo univoco e salvalo come un vettore che è zero dove è zero e l'id positivo univoco altrimenti.$X$

2. Per ogni riga rimanente assegnare gli ID univoci (non riassegnare mai gli ID univoci precedenti, assicurarsi che gli ID siano in costante aumento) alle sottostringhe di quella riga. Visualizza la riga precedente più la riga corrente come una matrice per m e tutte le aree connesse dovrebbero essere assegnate al minimo. Come esempio:$2$$m$

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

   Non è necessario aggiornare la riga precedente per la correttezza di questo algoritmo, solo quello corrente.

   Al termine, trova il set di tutti gli ID nella riga precedente che non si connettono alla riga successiva, eliminando i duplicati . Aggiungi le dimensioni di questo set al tuo contatore di isole in esecuzione.

   Ora puoi scartare la riga precedente e assegnare la riga corrente alla riga precedente e andare avanti.

3. Per gestire correttamente l'ultima riga fingere che ci sia un'altra fila di zeri nella parte inferiore di ed eseguire nuovamente il passaggio 2.$X$

Orlp fornisce una soluzione usando parole di spazio, che sono O ( n log n ) bit di spazio (supponendo per semplicità che n = m ). Viceversa, è facile dimostrare che Ω ( n ) bit di spazio sono necessari riducendo la disunione impostata al problema.$O(n)$$O(n\log n)$$n=m$$\Omega(n)$

Supponiamo che Alice detenga un vettore binario e Bob detenga un vettore binario y 1 , ... , y n e che vogliano sapere se esiste un indice i tale che x i = y i = 1 . Eseguono il tuo algoritmo per la matrice 2 × ( 2 n - 1 ) le cui righe sono x 1 , 0 , x 2 , 0 , ... $x_1,\ldots,x_n$$y_1,\ldots,y_n$$i$$x_i=y_i=1$$2\times(2n-1)$ ed y 1 , 0 , y 2 , 0 , ... , 0 , y n . Dopo aver letto la prima riga, Alice invia Bob ∑ i x i così come i contenuti della memoria, in modo che Bob possa completare l'algoritmo e confrontare ∑ i ( x i + y i ) con il numero di componenti collegati. Se i due numeri corrispondono, i due vettori sono disgiunti (non vi è alcun indice i ) e viceversa. Dal momento che qualsiasi protocollo per impostare le esigenze di disgiunzione$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$ bit (anche se può errare con una piccola probabilità costante), deduciamo unlimite inferiore di Ω ( n ) , che vale anche per i protocolli randomizzati a cui è consentito errare con qualche piccola probabilità costante.$\Omega(n)$$\Omega(n)$

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