Эффективное удаление дубликатов с небольшим объемом памяти

Я хочу эффективно отфильтровать список целых чисел для дубликатов таким образом, чтобы хранить только полученный набор.

Один способ это можно увидеть:

у нас есть диапазон целых чисел с большим (скажем, ) $S = \{1, \dots{}, N\}$ $N$ $2^{40}$
у нас есть функция с, предположительно, многими столкновениями (изображения равномерно распределены в ) $f : S \to S$ $S$
тогда нам нужно хранить , то есть $f[S]$ $\{f(x) | x \in S\}$

У меня есть достаточно точная (вероятностная) оценка того, что есть, и поэтому может выделять структуры данных заранее (скажем, ). $|f[S]|$ $|f[S]| \approx 2^{30}$

У меня было несколько идей, но я не уверен, что будет лучшим подходом:

о наборе битов не может быть и речи, потому что входной набор не помещается в память.
хеш-таблицу, но (1) она требует некоторой перегрузки памяти, скажем, 150% от и (2) таблица должна быть исследована при сборке, что требует дополнительного времени из-за нехватки памяти. $|f[S]|$
сортировка «на лету», предпочтительно со сложностью (сортировка без сравнения). В связи с этим я не уверен, в чем заключается основное различие между сортировкой сегментов и флэш- сортировкой . $O(N)$
простой массив с бинарным деревом поиска, но для этого требуется время . $O(N \log |f[S]|)$
возможно, использование фильтров Блума или подобной структуры данных может быть полезно для ослабления (с ложными срабатываниями) проблемы.

Некоторые вопросы по stackoverflow, кажется, решают такие вещи ( /programming/12240997/sorting-array-in-on-run-time , /programming/3951547/java -array-find-duplicates ), но ни один из них не соответствует моим требованиям.

algorithms data-structures sorting

— доктор
источник

Вам нужно перечислить f [S] (что бы это ни было) или уметь быстро определить, есть ли в нем какой-то x?

— Жиль "ТАК ... перестать быть злым"

@ Жиль: Я считаю, что, поскольку в f [S] не может быть найдено никакой очевидной структуры, оба решения эквивалентны.

— док.

Ваши номера не складываются. Ожидается изображение случайной функции на области размером

составляет примерно

. Другая проблема заключается в том, что проход через

займет слишком много времени, если в вашем распоряжении нет суперкомпьютера или большого кластера.

N

$N$

(1 - 1 / e) N

$(1-1/e)N$

2^{56}

$2^{56}$

— Юваль Фильмус

Время для двоичного дерева поиска будет

, котороена практикеможет быть или не быть близко к

но все же является более точным.

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

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

O (N \log N)

$O(N\log N)$

— Джмад

, не будет линейный алгоритм времени непомерно тоже? (По моим расчетам, даже если вы рассмотрите один элемент

за 1 наносекунду, это займет у вас хорошие 2 года!).

N \sim 2^{56}

$N \sim 2^{56}$

S

$S$

— Арьябхата

Почему не мусорное ведро и цепь?

Идея состоит в том, чтобы хранить натуральные числа, представимые битами, в массиве из $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$ где имеет битов, а имеет битов. Попробуйте сохранить (не !) В месте : $x = 2^m y + z$ $y$ $k$ $z$ $m$ $z$ $x$ $y$

Когда , ничего не делать: является дубликатом. $A[y]=z$ $x$
Когда не инициализирован, сохраните в . $A[y]$ $z$ $A[y]$
В противном случае сохраните индекс в отдельном массиве, который используется для связывания (которые столкнулись в точке ) в связанных списках. Вам нужно будет выполнить линейный поиск по списку, возглавляемому и, в зависимости от того, что обнаруживает поиск, потенциально вставить в список. $z$ $y$ $A[y]$ $z$

В конце концов, легко восстановить, просматривая инициализированные записи и - путем простого объединения двух цепочек битов - повторной сборки каждого найденного в местоположении (либо непосредственно, либо внутри цепочки, на которую есть ссылка), в исходную значение . $f(S)$ $A$ $z$ $y$ $x = 2^m y + z$

Когда распределение близко к равномерному и превышает , цепочки не будет много (это можно оценить обычными способами), и цепочки будут иметь тенденцию быть короткими. Когда распределение неоднородно, алгоритм все еще работает, но может достигнуть квадратичной синхронизации. Если это возможно, используйте что-то более эффективное, чем цепочки (и заплатите немного за хранение). $2^k$ $N$

Необходимая память составляет не более битов для и битов для цепочек (при условии, что ). Это именно то пространство, которое требуется для хранения значений по битов каждое. Если вы уверены в единообразии, вы можете перераспределить хранилище для цепей. Если возможна неоднородность, вы можете увеличить и полностью защитить цепочку хранения. $2^n$ $A$ $2^{2k}$ $m \le k$ $2^k$ $n$ $k$

Альтернативный способ мышления об этом решении является то , что она является хэш - таблица с особенно хорошей хеш - функции (взять наиболее значимые биты) , и из - за этого, мы только должны хранить наименее значимый битов стол. $k$ $m=n-k$

Существуют способы наложения хранилища для цепей на хранилище для но, похоже, это не стоит беспокоиться, потому что это не сэкономит много (при условии, что намного меньше, чем ) пространства и усложнит разработку кода, отлаживать и поддерживать. $A$ $m$ $k$

— whuber
источник

Я думаю, что второй-последний абзац здесь центральный, и, вероятно, должен быть наверху (как идея). Я не знаю термин «мусорное ведро» (хотя это имеет смысл после прочтения поста). Эта идея может быть распространена на попытки .

— Рафаэль

Итак, это

на плохо распределенных входах. Я не вижу, насколько это эффективно.

Θ (n^{2})

$\Theta(n^2)$

— einpoklum

@einpoklum Этот ответ явно описывает условия, в которых решение является эффективным.

— whuber