Struttura dei dati per l'intersezione impostata?

21

Esiste una struttura di dati che mantenga una raccolta di set (di set di terra finito) a supporto delle seguenti operazioni? Qualche tempo di esecuzione sublineare sarà apprezzato?

Init un set vuoto.
Aggiungi un elemento a un set.
Dato due set, segnala se si intersecano.

data-structures sets

— Dawei Huang
fonte

1

Questa è una domanda molto generale, poiché qualsiasi struttura di dati può supportare quelle operazioni con dominio finito. Potresti essere un po 'più specifico? Per esempio. Di quale complessità hai bisogno, cosa sei disposto a sacrificare per ottenere operazioni sul set ecc.

— Bartosz Przybylski,

13

Se ogni set mantiene un registro di quali altri set esistono e hai un totale di $s > 0$ set, puoi facilmente trasformare qualsiasi struttura di dati per una raccolta ( ad es . Alberi di ricerca binari, ecc. ) In uno in cui puoi recuperare un elemento dell'intersezione di due insiemi nel tempo $O(\log s)$ .

Ogni set dovrebbe avere un identificatore univoco rispetto a un set totalmente ordinato. Se assegni esplicitamente i tuoi insiemi $S_1, S_2, \ldots$ l'identificatore potrebbe essere solo l'indice.
È necessario implementare un "registro" degli insiemi; una struttura di dati che mantiene una raccolta di tutti i set che sono stati definiti. Il registro deve essere implementato come una struttura di dati dell'albero di ricerca, per consentire un facile recupero ( ad esempio se si desidera eliminare il set) e l'attraversamento lineare dei set.
Ogni set $S_j$ mantiene anche un "indice" di ciascuno degli altri set - non una copia di essi, ma piuttosto una struttura di dati che viene indicizzata dalle etichette degli altri set. Questo indice verrà utilizzato per mantenere, per ogni set $S_k$ , un albero di ricerca binario di tutti gli elementi di $S_j \cap S_k$ . (I due set $S_j$ e $S_k$ condividono una copia di quell'albero di ricerca.)

Inizializzazione

L'inizializzazione di un set consiste in operazioni per inizializzare l'albero dei suoi elementi, operazioni mentre si inizializza (copiando dal registro) l'indice per l'insieme e operazioni mentre attraversi il registro per aggiungere negli indici di ciascuno degli altri insiemi . Nell'indice di , creiamo alberi di ricerca che rappresentano per gli altri insiemi ; copiamo lo stesso puntatore per l'indice di . $T = \varnothing$ $O(1)$ $O(s)$ $T$ $O(s \log s)$ $T$ $S_j$ $T$ $T \cap S_j = \varnothing$ $S_j$ $S_j$

Aggiunta di un elemento a un set $T$

L'aggiunta di alcuni all'insieme richiede , dove. Testiamo anche l'appartenenza di in ciascuno degli altri set , che richiede tempo doveè la dimensione dell'universo (o del set più grande ) e è il numero di set nel registro. Per ogni insieme tale che , anche inserto nell'indice per il set . Per ciascuno di questi set $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$ , ciò richiede tempo, per cercare nell'indice di e per inserire in ; in tutti i set questo richiede tempo . Se supponiamo che il numero di insiemi sia molto inferiore alla dimensione dell'universo (ovvero, se supponiamo ), il tempo totale per l'inserimento dell'elemento è quindi .

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

Se non si consente duplicati in serie, siamo in grado di risparmiare tempo nel caso in cui già rinunciando alla prova di appartenenza e inserimenti per le altre serie . "Inserimento" nel caso in cui sia già presente, richiede solo tempo . $x \in S$ $T$ $x$ $O(\log n_T)$

Test di intersezione

L'indice di ciascun set viene mantenuto precisamente per consentire una rapida valutazione dell'intersezione tra due set e . Per un set , semplicemente controllando il suo indice per il set , non possiamo solo determinare in tempo se interseca o meno , ma possiamo anche recuperare un albero binario contenente l'intero set . $S_j$ $S_k$ $S_j$ $S_k$ $O(\log s)$ $S_j$ $S_k$ $S_j \cap S_k$

Rimozione dell'elemento

Per eliminare un elemento da un set , lo rimuoviamo non solo dall'albero di ricerca per stesso, ma da ciascuna delle intersezioni per gli insiemi nel suo indice. Questo richiede tempo , dove. $x$ $T$ $T$ $S_j \cap T$ $S_j$ $O(s \log n_T)$ $n_T = |T|$

Imposta cancellazione

A causa del sovraccarico di ricerca nel registro, se si hanno molti set, potrebbe essere preferibile eliminare i set quando non sono più necessari. Attraversando l'intero registro, possiamo eliminare dall'indice di tutti gli altri insiemi nel tempo , dominato dal costo di eliminazione dell'albero di ricerca che rappresenta per ciascuno degli altri insiemi , dove. $S$ $S_j$ $O(sn_T)$ $S_j \cap T$ $S_j$ $n_T = |T|$

Osservazioni

Se si prevede di implementare solo un numero costante di insiemi, i tempi di esecuzione sopra indicati si riducono a:

inizializzazione: $O(1)$
inserimento elemento: $O(\log n)$
test di intersezione (e recupero dell'intersezione): $O(1)$
rimozione elemento: $O(\log n_T)$
imposta la cancellazione: $O(n_S)$

dove è la dimensione del set più grande nel registro eper il set cui si sta operando. $n$ $n_T = |T|$ $T$

Se prevedete di avere set , dove è il vostro universo, potreste aver bisogno di una struttura dati diversa se volete che queste operazioni operino in un tempo sub-lineare. Tuttavia, se si hanno coppie di insiemi di cui si sa che non si proveranno mai intersezioni, è possibile ridurre le dimensioni dell'indice per gli insiemi (non includendo insiemi di cui si verificherà l'intersezione) o utilizzare più di un registro ( uno per ogni raccolta di insiemi di cui potresti verificare l'intersezione). In effetti, un registro è utile solo se si desidera un controllo centralizzato per garantire che ogni coppia di insiemi abbia una registrazione reciproca nell'indice: può essere pratico in alcuni casi, all'inizializzazione di una serie , semplicemente registrare l' annuncio hoc $O(|V|)$ $V$ $S$ ogni nuovo set negli indici degli altri set cui sei interessato all'intersezione con $T$ $S$

— Niel de Beaudrap
fonte

6

Esistono strutture di dati che ti consentono di farlo in tempi non lineari, anche per input nel caso peggiore. Vedere http://research.microsoft.com/pubs/173795/vldb11intersection.pdf (e i riferimenti dei documenti in esso).

Se i tuoi due set S e T hanno una grande intersezione e hai un dizionario per S, cercare elementi di T in ordine casuale dovrebbe darti rapidamente un elemento comune. Il caso più difficile è quando la dimensione dell'intersezione è 0 o 1.

— Rasmus Pagh
fonte

3

Di solito il tuo linguaggio di programmazione preferito supporterà una struttura di dati con elementi unici. In generale ci sono tre approcci popolari: alberi, hash e maschere di bit. Gli elementi dell'albero devono essere comparabili, gli elementi hash devono essere hash e gli elementi maschera di bit devono avere un modo di conversione in numeri interi.

Un set di alberi supporterà l'inserimento in O (registro n) e il test di intersezione nel Caso peggiore O (n registro n).

Un set di hash supporterà l'inserimento in O ammortizzato (1 * h) dove 'h' è il tempo di esecuzione dell'algoritmo di hashing e il test di intersezione nel Caso peggiore O (n).

I set di maschere di bit non sono generalmente usati come set di alberi e hash.

— Karl Damgaard Asmussen
fonte

2

Questa sarebbe una risposta decente da Stack Overflow , ma qui vorremmo qualche dettaglio su come e perché funziona.

— Raffaello

3

Se il tuo caso consente risposte false positive, utilizzerei Bloom Filter con una singola funzione hash.

Puoi implementarlo come segue:

Init un set vuoto

$B$ $n$ $n$

Aggiungi un elemento a un set.

$B[hash(element)]=1$

Dati due insiemi (B1, B2), segnalano se si intersecano.

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

Complessità

$n$ $O(1)$

— Grisha Weintraub
fonte