Rimozione dei duplicati in modo efficiente e con un sovraccarico di memoria insufficiente

Voglio filtrare in modo efficiente un elenco di numeri interi per i duplicati in modo che solo il set risultante debba essere memorizzato.

In un modo questo può essere visto:

abbiamo un intervallo di numeri interi $S = \{1, \dots{}, N\}$ con $N$ grande (diciamo $2^{40}$ )
abbiamo una funzione $f : S \to S$ con, presumibilmente, molte collisioni (le immagini sono distribuite uniformemente in $S$ )
dobbiamo quindi memorizzare , ovvero $f[S]$ $\{f(x) | x \in S\}$

Ho una stima (probabilistica) abbastanza accurata di cosa è e può quindi allocare in anticipo le strutture di dati (diciamo ). $|f[S]|$ $|f[S]| \approx 2^{30}$

Ho avuto alcune idee, ma non sono sicuro di quale sarebbe l'approccio migliore:

un bitset è fuori discussione perché il set di input non si adatta alla memoria.
una tabella hash, ma (1) richiede un sovraccarico di memoria, diciamo il 150% di e (2) la tabella deve essere esplorata quando costruita, il che richiede tempo aggiuntivo a causa del sovraccarico di memoria. $|f[S]|$
un ordinamento "al volo", preferibilmente con $O(N)$ (ordinamento non comparativo). A tal proposito, non sono sicuro di quale sia la differenza principale tra il bucket bucket e il flashsort .
un array semplice con un albero di ricerca binario, ma richiede tempo . $O(N \log |f[S]|)$
magari usando filtri Bloom o una struttura dati simile potrebbe essere utile in un rilassamento (con falsi positivi) del problema.

Alcune domande su StackOverflow sembrano affrontare questo tipo di cose ( /programming/12240997/sorting-array-in-on-run-time , /programming/3951547/java -array-trovando-duplicati ), ma nessuno sembra corrispondere ai miei requisiti.

algorithms data-structures sorting

— doc
fonte

Devi enumerare f [S] (qualunque esso sia) o essere in grado di dire rapidamente se c'è qualche x?

— Gilles 'SO- smetti di essere malvagio' il

@Gilles: credo che, poiché non è possibile trovare una struttura ovvia in f [S], le due soluzioni siano equivalenti.

— doc,

I tuoi numeri non si sommano. L'immagine atteso di una funzione a caso su un dominio di dimensioni

è approssimativamente

. Un altro problema è che passare attraverso

impiegherà troppo tempo a meno che tu non abbia un supercomputer o un cluster di grandi dimensioni a tua disposizione.

N

$N$

(1 - 1 / e) N

$(1-1/e)N$

2^{56}

$2^{56}$

— Yuval Filmus,

Il tempo per l'albero di ricerca binario sarebbe

, chein praticapotrebbe essere o meno vicino a

ma è comunque più preciso.

O (N \log | f [S] |)

$O(N \log |f[S]|)$

O (N \log N)

$O(N\log N)$

— jmad,

Con

, un algoritmo temporale lineare non sarebbe anche proibitivo? (Dai miei calcoli, anche se consideri un elemento di

in 1 nano-secondo, ti occorrerebbero ben 2 anni!).

N \sim 2^{56}

$N \sim 2^{56}$

S

$S$

— Aryabhata,

Perché non bin and chain?

L'idea è di memorizzare numeri interi positivi rappresentabili con bit in un array di voci che rappresentano intervalli di valori: la voce , , rappresenta l'intervallo . Per ogni possiamo scrivere $n = k+m$ $A$ $2^k$ $A[y]$ $y \ge 0$ $[2^m y, 2^m(y+1)-1]$ $1 \le x \lt 2^n$ dove ha bit e ha bit. Prova a memorizzare (non !) Nella posizione : $x = 2^m y + z$ $y$ $k$ $z$ $m$ $z$ $x$ $y$

Quando già, non fare nulla: è un duplicato. $A[y]=z$ $x$
Quando non è inizializzato, memorizzare in . $A[y]$ $z$ $A[y]$
Altrimenti, memorizza un indice in un array separato utilizzato per concatenare le (che si sono scontrate con ) negli elenchi collegati. Dovrai cercare in modo lineare nell'elenco diretto da e, a seconda di ciò che la ricerca scopre, potenzialmente inserisci nell'elenco. $z$ $y$ $A[y]$ $z$

Alla fine, è facile da recuperare ripetendo ciclicamente le voci inizializzate di e - semplicemente concatenando due stringhe di bit - riassemblando ciascuna trovata nella posizione (direttamente o all'interno di una catena a cui si fa riferimento) nell'originale valore . $f(S)$ $A$ $z$ $y$ $x = 2^m y + z$

Quando la distribuzione è vicina all'uniforme e supera , non ci sarà molto concatenamento (questo può essere valutato nei modi consueti) e le catene tenderanno ad essere corte. Quando la distribuzione non è uniforme, l'algoritmo funziona ancora, ma può raggiungere una tempistica quadratica. Se questa è una possibilità, usa qualcosa di più efficiente delle catene (e paga un po 'di spese generali per lo stoccaggio). $2^k$ $N$

La memoria necessaria è al massimo bit per e bit per le catene (assumendo $2^n$ $A$ $2^{2k}$ $m \le k$ ). Questo è esattamente lo spazio necessario per memorizzare valori di bit ciascuno. Se sei sicuro dell'uniformità, puoi sottoallocare lo spazio di archiviazione per le catene. Se la non uniformità è una possibilità, è possibile che si desideri aumentare e sostenere completamente la memorizzazione a catena. $2^k$ $n$ $k$

Un modo alternativo di pensare a questa soluzione è che tratta di una tabella hash con una funzione hash particolarmente bella (prendi i bit più significativi) e, per questo, abbiamo solo bisogno di memorizzare i bit meno significativi in la tavola. $k$ $m=n-k$

Esistono modi per sovrapporre l'archiviazione per le catene con l'archiviazione per $A$ ma non sembra preoccuparsi, perché non risparmierebbe molto spazio (supponendo che sia molto più piccolo di ) e renderebbe più difficile lo sviluppo del codice, debug e manutenzione. $m$ $k$

— whuber
fonte

Penso che il penultimo paragrafo sia quello centrale qui, e probabilmente dovrebbe essere in cima (come idea). Non conosco il termine "bin and chain" (anche se ha senso dopo aver letto il post). Questa idea può essere estesa ai tentativi .

— Raffaello

Quindi, questo è

su input scarsamente distribuiti. Non vedo come sia efficiente.

Θ (n^{2})

$\Theta(n^2)$

— einpoklum,

@einpoklum Questa risposta descrive esplicitamente le condizioni in cui la soluzione è efficiente.

— whuber