Структура даних для встановлення перетину?

21

Чи є структура даних, яка підтримує набір (з кінцевим набором наземних), що підтримує наступні операції? Буде оцінено будь-який підлінійний час роботи?

Запустіть порожній набір.
Додайте елемент до набору.
Дано два набори, повідомте, чи перетинаються вони.

data-structures sets

— Давей Хуан
джерело

1

Це дуже загальне питання, оскільки будь-яка структура даних може підтримувати ці операції з обмеженою областю. Чи можете ви бути трохи більш конкретним? Напр. Яка складність вам потрібна, що ви готові принести в жертву, щоб отримати операції тощо

— Bartosz Przybylski

13

Якщо кожен набір підтримує запис про те, що існують інші набори, і у вас є загальна кількість наборів, ви можете легко перетворити будь-яку структуру даних для колекції ( наприклад, двійкові дерева пошуку тощо ) в ту, де ви можете отримати пошук елемент перетину двох множин у часі . $s > 0$ $O(\log s)$

Кожен набір повинен мати унікальний ідентифікатор від деякого повністю упорядкованого набору. Якщо ви чітко називаєте свої набори тоді ідентифікатором може бути просто індекс. $S_1, S_2, \ldots$
Ви повинні реалізувати "реєстр" наборів; структура даних, яка підтримує набір усіх визначених вами наборів. Реєстр повинен бути реалізований як структура даних дерева дерева пошуку, щоб забезпечити просте пошуку ( наприклад, якщо ви хочете видалити набір) та лінійне проходження часу наборів.
Кожен набір також підтримує "індекс" кожного з інших наборів - не їх копію , а структуру даних, яка індексується мітками інших наборів. Цей індекс буде використовуватися для підтримки для кожного набору , двійкового дерева пошуку всіх елементів . (Два набори і ділять одну копію цього дерева пошуку.) $S_j$ $S_k$ $S_j \cap S_k$ $S_j$ $S_k$

Ініціалізація

Ініціалізація множини складається з операцій з ініціалізації дерева його елементів, операцій під час ініціалізації (копіювання з реєстру) індексу для набору , а операції під час проходження реєстру для додавання до індексів кожного з інших наборів . В індексі ми створюємо дерева пошуку, що представляють $T = \varnothing$ $O(1)$ $O(s)$ $T$ $O(s \log s)$ $T$ $S_j$ $T$ $T \cap S_j = \varnothing$ для інших множин ; ми копіюємо той же покажчик для індексу . $S_j$ $S_j$

Додавання елемента до набору $T$

Додавання деякого до множини вимагає часу як звичайно, де . Ми також перевіряємо приналежність у кожному з інших наборів , що вимагає часу $x \in V$ $T$ $O(\log n_T)$ $n_T = |T|$ $x$ $S_1, S_2, \ldots$ де- розмір Всесвіту (або найбільшого набору ) і - кількість наборів у реєстрі. Для кожного безлічі такещо ,також вставка в індекс для безлічі . Для кожного такого набору , це займає час, щоб подивитися

O (\log n_{S_{1}} + \log n_{S_{2}} + \dots) \subseteq O (s \log n),

$O(\log n_{S_1} + \log n_{S_2} + \cdots) \subseteq O(s \log n) ,$

n = | V |

$n = |V|$

S_{j}

$S_j$

s

$s$

S_{j}

$S_j$

x \in S_{j}

$x \in S_j$

x

$x$

S_{j} \cap T

$S_j \cap T$

S_{j}

$S_j$

O (\log s + \log n_{T})

$O(\log s + \log n_T)$

S_{j}

$S_j$ в індекс

і вставити

у

; для всіх безлічі

цього потрібен час

. Якщо припустити, що кількість множин

набагато менша за розмір Всесвіту

(тобто, якщо припустити, що

), то загальний час для вставки елемента - це

T

$T$

x

$x$

S_{j} \cap T

$S_j \cap T$

S_{1}, S_{2}, \dots

$S_1, S_2, \ldots$

O (s \log s + s \log n_{T})

$O(s \log s + s \log n_T)$

S_{j}

$S_j$

V

$V$

s ≪ n

$s \ll n$

O (s \log n)

$O(s \log n)$ .

Якщо ви не допускаєте дублікати в наборах, ми можемо заощадити час в тому випадку, коли вже за рахунок відмови від тестування членства і вставок для інших наборів . "Вставка" у випадку, коли вже присутній, тоді потрібен час лише . $x \in S$ $T$ $x$ $O(\log n_T)$

Випробування на перехресті

Індекс кожного набору підтримується саме для того, щоб дати можливість швидко оцінити, чи перетинаються два набори і . Для безлічі , просто шляхом перевірки його індексу для безлічі , ми не можемо визначити тільки під час або НЕ перетинає , але ми можемо також отримати бінарне дерево , що містить повний набір . $S_j$ $S_k$ $S_j$ $S_k$ $O(\log s)$ $S_j$ $S_k$ $S_j \cap S_k$

Видалення елемента

Щоб видалити елемент з множини , ми видаляємо його не тільки з дерева пошуку для самого , але з кожного з перетинів для множин у своєму індексі. Для цього потрібен час , де . $x$ $T$ $T$ $S_j \cap T$ $S_j$ $O(s \log n_T)$ $n_T = |T|$

Встановити видалення

Через накладні пошуки реєстру, якщо у вас є безліч наборів, можливо, буде бажано видалити набори, як тільки вони більше не потрібні. Пройшовши весь реєстр, ми можемо видалити з індексу всіх інших наборів за часом , домінуючи на витрату на видалення дерева пошуку, що представляє для кожного з інших наборів , де . $S$ $S_j$ $O(sn_T)$ $S_j \cap T$ $S_j$ $n_T = |T|$

Зауваження

Якщо ви плануєте впровадити лише постійну кількість наборів, то наведені вище періоди виконання зменшуються до:

ініціалізація: $O(1)$
Вставка елемента: $O(\log n)$
випробування на перехресті (та пошук перехрестя): $O(1)$
видалення елемента: $O(\log n_T)$
встановити видалення: $O(n_S)$

де - розмір найбільшого набору в реєстрі, а для набору яким ви працюєте. $n$ $n_T = |T|$ $T$

Якщо ви очікуєте, що у вас є набори , де - ваша всесвіт, вам може знадобитися інша структура даних, якщо ви хочете, щоб ці операції працювали в підлінійний час. Однак якщо у вас є пари множин, перетин яких ви знаєте, що ви ніколи не перевірите, ви, можливо, зможете зменшити розмір індексу для наборів (не включаючи жодних наборів, перетин яких ви протестуєте) або використовувати більше одного реєстру ( по одному для кожної колекції наборів, перетин яких ви можете протестувати). Насправді, реєстр корисний лише у тому випадку, якщо ви хочете централізовано контролювати, щоб кожна пара наборів записувала один одного в індексі: це може бути практично в деяких випадках при ініціалізації набору просто для запису $O(|V|)$ $V$ $S$ $T$ $S$

— Ніль де Бодорап
джерело

6

Існують структури даних, які дозволяють зробити це за менший за лінійний час навіть для найгірших даних. Див. Http://research.microsoft.com/pubs/173795/vldb11intersection.pdf (та посилання на документи там).

Якщо ваші два набори S і T мають велике перетин і у вас є словник для S, пошук елементів T у випадковому порядку повинен швидко дати вам загальний елемент. Найскладніший випадок, коли розмір перетину дорівнює 0 або 1.

— Расмус Паг
джерело

3

Зазвичай ваша мова програмування на вибір підтримуватиме структуру даних з унікальними елементами. Загалом є три популярні підходи: Дерева, Хеші та Бітмаски. Елементи дерева повинні бути порівнянними, елементи Hash повинні бути доступними, а елементи Bitmask повинні мати певний спосіб перетворення в цілі числа.

Набір дерев підтримуватиме вставлення в O (log n) та тестування перетину в Worst Case O (n log n).

Хеш-набір підтримуватиме вставку в Amortized O (1 * h), де 'h' - час роботи алгоритму хешування, і тест перетину в Worst Case O (n).

Набори біткої маски зазвичай не використовуються, як набори дерев і хешів.

— Карл Дамгаард Асмуссен
джерело

2

Це була б гідна відповідь на переповнення стека , але тут ми хотіли б трохи детальніше про те, як і чому це працює.

— Рафаель

3

Якщо ваш випадок дає хибні позитивні відповіді, я б використовував Bloom Filter з однією хеш-функцією.

Ви можете реалізувати його наступним чином:

Запустіть порожній набір

$B$ = бітовий масив $n$ біт, усі встановлені на 0. ( $n$ should be chosen according to the number of possible elements)

Add an element to a set.

$B[hash(element)]=1$

Given two sets(B1,B2), report whether they intersect.

check if $B1$ $AND$ $B2$ $=$ $0$

Complexity

If $n$ is not too big, all operations are $O(1)$ .

— Grisha Weintraub
джерело