Supprimer les doublons efficacement et avec une surcharge de mémoire faible

Je veux filtrer efficacement une liste d'entiers pour les doublons d'une manière que seul l'ensemble résultant doit être stocké.

Cela peut être vu d'une manière:

nous avons une gamme d'entiers $S = \{1, \dots{}, N\}$ avec $N$ grand (disons $2^{40}$ )
nous avons une fonction $f : S \to S$ avec, supposément, de nombreuses collisions (les images sont uniformément réparties dans $S$ )
il faut alors stocker $f[S]$ , c'est-à-dire $\{f(x) | x \in S\}$

J'ai une estimation (probabiliste) assez précise de ce qui $|f[S]|$ est, et peut donc allouer des structures de données à l'avance (disons $|f[S]| \approx 2^{30}$ ).

J'ai eu quelques idées, mais je ne sais pas quelle serait la meilleure approche:

un jeu de bits est hors de question car l'ensemble d'entrée ne tient pas en mémoire.
une table de hachage, mais (1) cela nécessite une surcharge de mémoire, disons 150% de et (2) la table doit être explorée lors de sa construction, ce qui nécessite du temps supplémentaire en raison de la surcharge de la mémoire. $|f[S]|$
un tri "à la volée", de préférence avec une complexité (tri sans comparaison). À ce sujet, je ne sais pas quelle est la principale différence entre le tri par compartiment et le tri flash . $O(N)$
un tableau simple avec un arbre de recherche binaire, mais cela nécessite temps. $O(N \log |f[S]|)$
peut-être que l'utilisation de filtres Bloom ou d'une structure de données similaire pourrait être utile pour détendre (avec des faux positifs) le problème.

Certaines questions sur stackoverflow semblent s'attaquer à ce genre de choses ( /programming/12240997/sorting-array-in-on-run-time , /programming/3951547/java -array-find-duplicates ), mais aucun ne semble correspondre à mes exigences.

algorithms data-structures sorting doc
la source

Avez-vous besoin d'énumérer f [S] (quel qu'il soit), ou de pouvoir dire rapidement s'il y a du x?

Gilles 'SO- arrête d'être méchant'

@ Gilles: Je pense que, comme aucune structure évidente ne peut être trouvée dans f [S], les deux solutions sont équivalentes.

doc

Vos chiffres ne correspondent pas. L'image attendue d'une fonction aléatoire sur un domaine de taille

est à peu près

. Un autre problème est que passer par

va prendre trop de temps, sauf si vous avez un supercalculateur ou un grand cluster à votre disposition.

N

$N$

(1 - 1 / e) N

$(1-1/e)N$

2^{56}

$2^{56}$

Yuval Filmus

Le temps pour l'arbre de recherche binaire serait

, qui peut être proche ou non de

en pratique mais qui est toujours plus précis.

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

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

O (N \log N)

$O(N\log N)$

jmad

Avec

, un algorithme de temps linéaire ne sera-t-il pas trop prohibitif? (D'après mes calculs, même si vous considérez un élément de

en 1 nano-seconde, cela vous prendrait 2 bonnes années!).

N \sim 2^{56}

$N \sim 2^{56}$

S

$S$

Aryabhata

Réponses:

Pourquoi pas un bac et une chaîne?

L'idée est de stocker des entiers positifs représentables par bits dans un tableau de entrées représentant des plages de valeurs: l'entrée , , représente la plage . Pour tout nous pouvons écrire $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$ où a bits et a bits. Essayez de stocker (pas !) À l'emplacement : $x = 2^m y + z$ $y$ $k$ $z$ $m$ $z$ $x$ $y$

Lorsque déjà, ne faites rien: est un doublon. $A[y]=z$ $x$
Lorsque n'est pas initialisé, stockez à . $A[y]$ $z$ $A[y]$
Sinon, stockez un index dans un tableau séparé utilisé pour enchaîner les (qui sont entrés en collision en ) dans des listes chaînées. Vous devrez effectuer une recherche linéaire dans la liste dirigée par et, selon ce que la recherche révèle, insérer potentiellement dans la liste. $z$ $y$ $A[y]$ $z$

À la fin, est facile à récupérer en parcourant les entrées initialisées de et - en concaténant simplement deux chaînes de bits - en réassemblant chaque trouvé à l'emplacement (soit directement soit dans une chaîne référencée ici) dans l'original valeur . $f(S)$ $A$ $z$ $y$ $x = 2^m y + z$

Lorsque la distribution est proche de l'uniforme et que dépasse , il n'y aura pas beaucoup de chaînage (cela peut être évalué de la manière habituelle) et les chaînes auront tendance à être courtes. Lorsque la distribution n'est pas uniforme, l'algorithme fonctionne toujours, mais peut atteindre un timing quadratique. Si c'est une possibilité, utilisez quelque chose de plus efficace que les chaînes (et payez un peu de frais généraux pour le stockage). $2^k$ $N$

Le stockage nécessaire est au maximum de bits pour et de bits pour les chaînes (en supposant que ). C'est exactement l'espace nécessaire pour stocker valeurs de bits chacune. Si vous êtes confiant dans l'uniformité, vous pouvez sous-allouer le stockage pour les chaînes. Si la non-uniformité est une possibilité, vous voudrez peut-être augmenter et préconiser pleinement le stockage en chaîne. $2^n$ $A$ $2^{2k}$ $m \le k$ $2^k$ $n$ $k$

Une autre façon de penser à cette solution est qu'il s'agit d' une table de hachage avec une fonction de hachage particulièrement agréable (prenez les bits les plus significatifs) et, à cause de cela, nous n'avons besoin que de stocker les bits les moins significatifs dans la table. $k$ $m=n-k$

Il existe des moyens de superposer le stockage pour les chaînes avec le stockage pour mais cela ne semble pas valoir la peine, car cela n'économiserait pas beaucoup (en supposant que est beaucoup plus petit que ) de l'espace et rendrait le code plus difficile à développer, déboguer et maintenir. $A$ $m$ $k$

Whuber
la source

Je pense que l'avant-dernier paragraphe est le principal ici, et devrait probablement être en haut (comme idée). Je ne connais pas le terme "bin and chain" (bien que cela ait du sens après avoir lu le post). Cette idée peut être étendue aux essais .

Raphael

Donc, c'est

sur des entrées mal réparties. Je ne vois pas comment cela est efficace.

Θ (n^{2})

$\Theta(n^2)$

einpoklum

@einpoklum Cette réponse décrit explicitement les conditions dans lesquelles la solution est efficace.

whuber