Determinazione del numero particolare in tempo e spazio (caso peggiore)

$\newcommand\ldotd{\mathinner{..}}$ Dato che $A[1\ldotd n]$ sono numeri interi tali che $0\le A[k]\le m$ per tutto $1\le k\le n$ e il verificarsi di ciascuno numero tranne un numero particolare in $A[1\ldotd n]$ è un numero dispari. Prova a trovare il numero la cui occorrenza è un numero pari.

Esiste un algoritmo $\Theta(n\log n)$ : $A[1\ldotd n]$ in $B[1\ldotd n]$ e suddividiamo $B[1\ldotd n]$ in molti pezzi, il cui valore degli elementi è il lo stesso, quindi possiamo contare l'occorrenza di ciascun elemento.

Voglio trovare un algoritmo di spazio $O(n)$ -time-e- caso peggiore $O(n)$ .

Supponendo che $m=\Omega(n^{1+\epsilon})$ e $\epsilon>0$ , quindi l'ordinamento radix non è accettabile. $\DeclareMathOperator{\xor}{xor}$ Le operazioni binarie bit a bit sono accettabili, ad esempio $A[1]\xor A[2]$ .

algorithms search-algorithms

— Yai0Phah
fonte

La risposta di Aryabhata che segue mostra che il caso generale non è buono, ma forse hai ulteriori restrizioni disponibili? Una semplice (ma grande) limitazione sarebbe quella di imporre che tutte le voci nell'array abbiano dimensioni

O (n)

$O(n)$ . Ciò darebbe un algoritmo lineare piuttosto banale.

— Luke Mathieson,

@LukeMathieson: ho eliminato quella risposta, poiché non sono ancora convinto che il documento che ho citato funzionerà senza alcuna modifica, e inoltre, OP sembra interessarsi solo al modello di RAM a costo uniforme.

— Aryabhata,

@Aryabhata: hehe, beh la risposta che non c'è allora! Per quanto interessante e forse utile per Frank, quale pensavi fosse il problema di adattare il risultato nel documento? Un rapido suggerimento suggerì che fosse applicato, ma ovviamente non avevo letto.

— Luke Mathieson,

@LukeMathieson: il fatto che gli altri elementi debbano apparire un numero dispari di volte nel problema attuale. Da allora, ho sfiorato anche la prova ...

— Aryabhata,

Sarebbe interessante se sei interessato a risultati teorici o a soluzioni pratiche. Dal punto di vista della teoria, la mia prima risposta rapida è che puoi ordinare un elenco di numeri interi più velocemente di . Esiste un algoritmo deterministico di Han che viene eseguito nel tempo . Per gli algoritmi randomizzati, sono noti risultati ancora migliori, ad esempio Han e Thorup hanno trovato un algoritmo di tempo previsto . Tuttavia, penso che il tuo problema non dovrebbe richiedere l'ordinamento.

O (n \log n)

$O(n\log n)$

O (\log \log n)

$O(\log\log n)$

O (n \sqrt{\log \log n})

$O(n \sqrt{\log\log n})$

— A.Schulz,

Risposte:

Ecco un'idea per un semplice algoritmo; conta solo tutte le occorrenze!

Trova . - time $m = \max A$ $\Theta(n)$
Matrice "Allocate" . - tempo ¹ $C[0..m]$ $O(1)$
Scorri su e aumenta di uno ogni volta che trovi . Se è , aggiungere ad una lista lineare . - time $A$ $C[x]$ $A[\_]=x$ $C[x]$ $0$ $x$ $L$ $\Theta(n)$
Scorrere su e trovare l'elemento con pari. - tempo . $L$ $x_e$ $C[x_e]$ $O(n)$
Ritorna . $x_e$

Tutto sommato, questo ti dà un algoritmo a tempo lineare che può usare (nel senso di allocare) molta memoria. Si noti che la possibilità di accedere casualmente a in tempo costante indipendentemente da è cruciale qui. $C$ $m$

Un ulteriore legato allo spazio è più difficile con questo approccio; Non conosco alcuna struttura di dati del dizionario che offra una ricerca temporale . Puoi usare le tabelle hash per le quali qui sono implementazioni con tempo di ricerca previsto ( la dimensione della tabella, il numero di elementi memorizzati) in modo da poter ottenere arbitrariamente bene con lo spazio lineare - nell'aspettativa. Se tutti i valori in mappa hanno lo stesso valore hash, sei fregato. $O(n)$ $O(1)$ $O(1 + k/n)$ $n$ $k$ $A$

Su una RAM, questo è implicitamente fatto; tutto ciò di cui abbiamo bisogno è la posizione iniziale e forse la posizione finale.

— Raffaello
fonte

Una soluzione quasi banale - che utilizza comunque lo spazio - è usare una mappa hash. Ricordiamo che una mappa hash ha ammortizzato il runtime per l'aggiunta e la ricerca di elementi. $\Theta(n)$ $\mathcal{O}(1)$

Quindi, possiamo usare il seguente algoritmo:

Allocare un hash mappa . Iterare su . Per ogni elemento , aumenta il numero di occorrenze osservate, ovvero . $H$ $A$ $i \in A$ $H(i)++$
Scorrere il set di chiavi della mappa hash e verificare quale delle chiavi ha un conteggio uniforme delle occorrenze.

Ora questo è un semplice algoritmo che in realtà non usa alcun trucco di grandi dimensioni, ma a volte anche questo è sufficiente. In caso contrario, potresti voler specificare quali restrizioni di spazio imponi.

— HdM
fonte

Vorrei ancora sapere se esiste un algoritmo non randomizzato che utilizza lo spazio polinomiale. In particolare, ci sono prove teoriche che trovare il solo oggetto che si verifica in modo equo sia più difficile che trovare l'unico oggetto che si presenta in modo strano?

O (n)

$O(n)$

— A.Schulz,

@ A.Schulz Penso che sia l' algoritmo -expected-time utilizzando la tabella hash. Ricordo che qualcuno mi ha detto un algoritmo (o per un caso speciale, diciamo, dispari = 1 e persino = 2) forse con stack, ma non riesco a ricordarlo.

O (n)

$O(n)$

O (n)

$O(n)$

— Yai0Phah,

Non tutte le implementazioni hashtable hanno questa proprietà; di solito, la ricerca non è , nemmeno ammortizzata (afaik). In effetti, una discussione precedente non ha prodotto alcuna implementazione con una ricerca temporale costante. Può essere più preciso?

O (1)

$O(1)$

— Raffaello