Datenstruktur für Schnittmenge festlegen?

19

Gibt es eine Datenstruktur, die eine Sammlung von Mengen (von endlichen Mengen) verwaltet, die die folgenden Operationen unterstützt? Jede sublineare Laufzeit wird geschätzt?

Initiere ein leeres Set.
Fügen Sie einem Set ein Element hinzu.
Geben Sie bei zwei Sätzen an, ob sie sich überschneiden.

data-structures sets

— Dawei Huang
quelle

1

Dies ist eine sehr allgemeine Frage, da jede Datenstruktur diese Operationen mit endlicher Domäne unterstützen kann. Könnten Sie etwas genauer sein? Z.B. Welche Komplexität benötigen Sie, was sind Sie bereit zu opfern, um Set-Operationen usw. zu bekommen

— Bartosz Przybylski

12

Wenn in jeder Gruppe eine Aufzeichnung darüber geführt wird, welche anderen Gruppen vorhanden sind, und Sie insgesamt Gruppen haben, können Sie jede Datenstruktur für eine Sammlung ( z. B. binäre Suchbäume usw. ) auf einfache Weise in eine Datenstruktur umwandeln, auf die Sie zugreifen können ein Element der Schnittmenge zweier Mengen in der Zeit . $s > 0$ $O(\log s)$

Jeder Satz sollte eine eindeutige Kennung von einem vollständig bestellten Satz haben. Wenn Sie Ihre Mengen explizit benennen könnte der Bezeichner nur der Index sein. $S_1, S_2, \ldots$
Sie sollten eine "Registrierung" der Sätze implementieren; eine Datenstruktur, die eine Sammlung aller von Ihnen definierten Mengen verwaltet. Die Registrierung sollte als Suchbaum-Datenstruktur implementiert werden, um ein einfaches Abrufen ( z. B. wenn Sie die Menge löschen möchten) und ein lineares Durchlaufen der Mengen zu ermöglichen.
Jede Menge auch einen "Index" jeder der anderen Mengen - keine Kopie davon, sondern eine Datenstruktur, die durch die Bezeichnungen der anderen Mengen indiziert wird. Dieser Index wird verwendet, um für jede Menge einen binären Suchbaum aller Elemente von . (Die beiden Mengen und teilen sich eine Kopie dieses Suchbaums.) $S_j$ $S_k$ $S_j \cap S_k$ $S_j$ $S_k$

Initialisierung

Initialisierung eines Satzes besteht aus Operationen des Tree seiner Elemente zu initialisieren, Operationen wie Sie initialisieren ( das Kopieren aus der Registrierung) der Index für den Satz und Operationen, während Sie die Registrierung durchlaufen, um zu den Indizes jeder der anderen Mengen hinzuzufügen . Im Index von erstellen wir Suchbäume, die $T = \varnothing$ $O(1)$ $O(s)$ $T$ $O(s \log s)$ $T$ $S_j$ $T$ $T \cap S_j = \varnothing$ für die anderen Mengen ; Wir kopieren den gleichen Zeiger für den Index von . $S_j$ $S_j$

Hinzufügen eines Elements zu einer Menge $T$

Das Addieren von zu der Menge benötigt wie üblich die Zeit , wobei . Wir testen auch die Zugehörigkeit von in jeder der anderen Mengen , die Zeit $x \in V$ $T$ $O(\log n_T)$ $n_T = |T|$ $x$ $S_1, S_2, \ldots$ wobeiist die Größe des Universums (oder der größten Menge ) und ist die Anzahl der Mengen in der Registrierung. für jede Menge so dass , auch in den Index für die Menge . Für jeden solchen Satz , nimmt diese Zeit, zu sehen

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$ im Index von

und

in

einzufügen ; über alle Mengen

dauert dies Zeit

. Wenn wir annehmen, dass die Anzahl der Mengen

viel kleiner ist als die Größe des Universums

(dh wenn wir annehmen, dass

), beträgt die Gesamtzeit für das Einfügen des Elements

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)$ .

Wenn Sie keine Duplikate in Sets ermöglichen, können wir die Zeit in dem Fall , dass speichern bereits durch den Verzicht auf die Mitgliedschaft Tests und Einfügungen für die anderen Sätze . "Einfügen" in dem Fall, dass bereits vorhanden ist, dauert dann nur noch . $x \in S$ $T$ $x$ $O(\log n_T)$

Schnittpunktprüfung

Der Index jedes Satzes wird genau beibehalten, um eine schnelle Beurteilung zu ermöglichen, ob sich zwei Sätze und schneiden oder nicht . Für eine Menge können wir , indem wir einfach ihren Index für die Menge prüfen , nicht nur in der Zeit bestimmen, ob schneidet oder nicht , sondern wir können auch einen Binärbaum abrufen, der die gesamte Menge enthält . $S_j$ $S_k$ $S_j$ $S_k$ $O(\log s)$ $S_j$ $S_k$ $S_j \cap S_k$

Elemententfernung

Um ein Element aus einer Menge zu löschen , entfernen wir es nicht nur aus dem Suchbaum für selbst, sondern aus jedem der Schnittpunkte für die Mengen in seinem Index. Dies dauert Zeit , wobei . $x$ $T$ $T$ $S_j \cap T$ $S_j$ $O(s \log n_T)$ $n_T = |T|$

Löschung einstellen

Aufgrund des mit dem Durchsuchen der Registrierung verbundenen Aufwands ist es möglicherweise wünschenswert, Sätze zu löschen, sobald sie nicht mehr benötigt werden. Durch die gesamte Registrierung durchlaufen, können wir löschen aus dem Index aller anderen Sätze in der Zeit , dominiert von den Kosten für das Löschen der Suchbaum darstellt für jedes der anderen Sätze mit . $S$ $S_j$ $O(sn_T)$ $S_j \cap T$ $S_j$ $n_T = |T|$

Bemerkungen

Wenn Sie nur mit einer konstanten Anzahl von Sätzen rechnen, reduzieren sich die oben genannten Laufzeiten auf:

Initialisierung: $O(1)$
Elementeinfügung: $O(\log n)$
Kreuzungstest (und Abruf der Kreuzung): $O(1)$
Elemententfernung: $O(\log n_T)$
Löschung festlegen: $O(n_S)$

Dabei ist die Größe der größten Menge in der Registrierung und für den Satz dem Sie arbeiten. $n$ $n_T = |T|$ $T$

$O(|V|)$ $V$ $S$ $T$ $S$

— Niel de Beaudrap
quelle

5

Es gibt Datenstrukturen, mit denen Sie dies auch bei Eingaben im ungünstigsten Fall in weniger als linearer Zeit tun können. Siehe http://research.microsoft.com/pubs/173795/vldb11intersection.pdf (und die dort angegebenen Artikel).

Wenn Ihre beiden Mengen S und T einen großen Schnittpunkt haben und Sie ein Wörterbuch für S haben, sollten Sie schnell ein gemeinsames Element finden, indem Sie die Elemente von T in zufälliger Reihenfolge nachschlagen. Der schwierigste Fall ist, wenn die Schnittmenge 0 oder 1 ist.

— Rasmus Pagh
quelle

3

Normalerweise unterstützt Ihre Programmiersprache eine Datenstruktur mit eindeutigen Elementen. Im Allgemeinen gibt es drei gängige Ansätze: Bäume, Hashes und Bitmasken. Tree-Elemente müssen vergleichbar sein, Hash-Elemente müssen hashbar sein und Bitmask-Elemente müssen eine Art Umwandlung in Ganzzahlen aufweisen.

Ein Tree-Set unterstützt das Einfügen in O (log n) und das Testen von Schnittpunkten in Worst Case O (n log n).

Ein Hash-Set unterstützt das Einfügen in Amortized O (1 * h), wobei 'h' die Laufzeit des Hash-Algorithmus ist, und den Schnittpunkttest in Worst Case O (n).

Bitmaskensätze werden im Allgemeinen nicht wie Baum- und Hash-Sätze verwendet.

— Karl Damgaard Asmussen
quelle

2

Dies wäre eine anständige Stack Overflow- Antwort, aber hier möchten wir einige Details darüber, wie und warum es funktioniert.

— Raphael

3

Wenn Ihr Fall falsch positive Antworten zulässt, würde ich Bloom Filter mit einer einzelnen Hash-Funktion verwenden.

Sie können es wie folgt implementieren:

Initiere ein leeres Set

$B$ $n$ $n$

Fügen Sie einem Set ein Element hinzu.

$B[hash(element)]=1$

Geben Sie bei zwei Sätzen (B1, B2) an, ob sie sich überschneiden.

$B1$ $AND$ $B2$ $=$ $0$

Komplexität

$n$ $O(1)$

— Grisha Weintraub
quelle