Strutture dati per insiemi disgiunti

1. Strutture dati per insiemi disgiunti Servono a mantenere una collezione C = {S1, S2, ... , Sk} di insiemi disgiunti. Ogni insieme della collezione è individuato da un rappresentante che è uno degli elementi dell’insieme.

2. Operazioni sugli insiemi disgiunti: MakeSet(x) : aggiunge alla struttura dati un nuovo insieme contenente solo l’elemento x. Si richiede che x non compaia in nessun altro insieme della struttura. FindSet(x) : ritorna il rappresentante dell’insieme che contiene x. Union(x, y) : riunisce i due insiemi contenenti xed y in un unico insieme.

3. Esercizio 29 Sia data una rete con n nodi x1, x2, … , xned m canali di trasmissione c1, c2, … , cme per ogni canale ci siano dati i due nodi xied yi che tale canale connette direttamente. Descrivere un algoritmo che utilizza una struttura dati per insiemi disgiunti per determinare se la rete è connessa, ossia se è sempre possibile mandare un messaggio da un qualsiasi nodo ad un qualsiasi altro nodo.

4. c h e b Rappresentazione con liste Il modo più semplice per rappresentare una collezione di insiemi disgiunti è usare una lista circolare per ciascun insieme.

5. x f x c h e I nodi hanno i seguenti campi: info : l’informazione contenuta nel nodo r: il puntatore al rappresentante succ : il puntatore al nodo successivo Le operazioni sono: MakeSet(x) x.r = x x.succ = x FindSet(x) returnx.r

6. x c h e b y f g d x c h e b y f g d Union(x,y)

7. Union(x, y) //cambia i puntatori rnella lista di y y.r = x.r, z = y.succ whilez ≠ y z.r= x.r, z = z.succ //concatena le due liste z = x.succ, x.succ= y.succ, y.succ= z La complessità di Union dipende dal numero di iterazioni richieste dal ciclo che cambia i puntatori al rappresentante dei nodi della lista contenente y. Quindi Unionha complessità O(n2) dove n2 è la lunghezza della seconda lista.

8. Consideriamo la sequenza di 2n-1 operazioni: MakeSet(x1) //costo 1 MakeSet(x2) //costo 1 ....... MakeSet(xn) //costo 1 Union(x2, x1) //costo 1 Union(x3, x1) //costo 2 Union(x4, x1) //costo 3 ....... Union(xn, x1) //costo n-1 Il costo totale è proporzionale ad n+n(n-1)/2 ed è (n2) e le operazione hanno costo ammortizzato O(n).

9. Euristica dell’unione pesata La complessità (n2) dell’esempio è dovuta al fatto che, in ogni Union, la seconda lista, quella che viene percorsa per aggiornare i puntatori al rappresentante, è la più lunga delle due. L’euristica dell’unione pesatasceglie sempre la lista più corta per aggiornare i puntatori al rappresentante.

10. L L L L 4 h # e # b # c L b b b b 1 h 0 e 0 b 0 c 4 Per poter fare ciò basta memorizzare la lunghezza della lista in un nuovo campo L del rappresentante. Si può risparmiare memoria usando un campo booleano b per distinguere il rappresentante.

11. Naturalmente occorre modificare le funzioni: MakeSet(x) x.b = true x.L = 1 x.succ = x FindSet(x) ifx.b returnx else returnx.r

12. Union(x, y) • x = FindSet(x) • y = FindSet(y) • //se la lista di xè più corta scambia xcony • ifx.L < y.L • z = x, x = y, y = z • x.L = x.L + y.L • //cambia rappresentante alla lista di y • y.b = false, y.r = x, z = y.succ • whilez ≠ y • z.r = x, z = z.succ • //concatena le due liste • z = x.succ, x.succ= y.succ, y.succ = z

13. Dimostreremo che con l’euristica dell’unione pesata una sequenza di m operazioni delle quali n sono MakeSetrichiede tempo O(m + n log n) La complessità ammortizzata delle operazioni è quindi: Se il numero n di MakeSetè molto minore di mper cuin log n = O(m)

14. Dimostrazione Tutte le operazioni richiedono un tempo costante eccetto Union che richiede un tempo costante più un tempo proporzionale al numero di puntatori al rappresentante che vengono modificati. Il tempo richiesto dalla sequenza di m operazioni è quindi O(m + N) dove N è il numero totale di aggiornamenti dei puntatori al rappresentante eseguiti durante tutta la sequenza di operazioni.

15. Il numero massimo di oggetti contenuti nella struttura è n: il numero di MakeSet. MakeSet(x) crea un insieme con un solo elemento. x.r viene aggiornato quando l’insieme viene unito ad un insieme di cardinalità maggiore o uguale per cui la cardinalità diventa almeno il doppio. Siccome un insieme non può avere più di n elementi x.rpuò essere aggiornato al più log2 nvolte. Quindi N ≤nlog2n.

16. Rappresentazione con foreste Una rappresentazione più efficiente si ottiene usando foreste di insiemi disgiunti. Ogni insieme è rappresentato da un albero i cui nodi, oltre al campo info che contiene l’informazione, hanno soltanto un campo p che punta al padre.

17. f c h e d b g

18. Implementazione semplice: MakeSet(x) x.p = x FindSet(x) whilex.p ≠ x x =x.p returnx Union(x, y) x = FindSet(x) y = FindSet(y) x.p = y //serve controllare se x ≠ y ?

19. c f f h e d d c b g h e g b y x x y

20. Osservazione. Sia nella rappresentazione con liste circolari che in quella con alberi non abbiamo indicato nessun puntatore esterno alla lista o all’albero. In realtà una struttura dati per insiemi disgiunti non è pensata per memorizzare dei dati ma soltanto per raggruppare in insiemi disgiunti dei dati che sono già memorizzati in qualche altra struttura: array, pila, lista, albero, tavola hash, ecc.

21. Complessità dell’implementazione semplice La complessità di FindSet(x) è pari alla lunghezza del cammino che congiunge il nodo x alla radice dell’albero. La complessità di Union è essenzialmente quella delle due chiamate FindSet(x) e FindSet(y). Un esempio analogo a quello usato con le liste mostra che una sequenza di n operazioni può richiedere tempo O(n2).

22. Possiamo migliorare notevolmente l’efficienza usando due euristiche: L’euristica dell’unione per rango: E’ simile a quella dell’unione pesata per le liste. In ogni nodo x manteniamo un campo rank che è un limite superiore all’altezza del sottoalbero di radice x ed è anche una approssimazione del logaritmo del numero di nodi del sottoalbero. L’operazione Union mette la radice con rango minore come figlia di quella di rango maggiore.

23. L’euristica della compressione dei cammini: Quando effettuiamo una FindSet(x) attraversiamo il cammino da x alla radice. Possiamo approfittarne per far puntare alla radice dell’albero i puntatori al padre di tutti i nodi incontrati lungo il cammino. Le successive operazioni FindSetsui nodi di tale cammino risulteranno molto meno onerose.

24. L’implementazione con entrambe le euristiche è la seguente: MakeSet(x) x.p = x x.rank = 0

25. f f d d x c b h c h e g e g x b FindSet(x) ifx.p ≠ x x.p =FindSet(x.p) returnx.p

26. Union(x, y) x = FindSet(x) y = FindSet(y) Link(x, y) Link(x, y) ifx.rank > y.rank y.p= x else x.p= y ifx.rank == y.rank y.rank =y.rank + 1

27. Considerazioni generali sulla complessità: Usate separatamente entrambe le euristiche (unione per rango e compressione dei cammini) migliorano le prestazioni. Con la sola euristica dell’unione per rango una sequenza di moperazioni delle quali n sono MakeSetrichiede tempo O(m log n)

28. Con la sola euristica della compressione dei cammini una sequenza di moperazioni delle quali n sono MakeSete ksono FindSetrichiede tempo Esempio: m ≥ 1000, n = 100 e k = 900 Esempio: m ≥1000, n = 512 e k = 100

29. Le migliori prestazioni in assoluto si ottengono usando entrambe le euristiche. Una sequenza di m operazioni delle quali n sono MakeSetrichiede tempo O(mα(n)) dove α(n) è una funzione che cresce estremamente lentamente: α(n) ≤ 4 in ogni concepibile uso della struttura dati. La complessità ammortizzata di una singola operazione risulta quindi O(α(n)): praticamente costante.

30. La funzione α(n) Iterazione di una funzione: Funzione di Ackermann: k è detto livellodella funzione.

31. Possiamo calcolare Ak(x)ricorsivamente nel modo seguente: • Ackerman(k, j) • ifk = 0 • returnj+1 • else • a = j • for i = 1toj+1 • a= Ackerman(k-1, a) • returna

32. Se il livello k è fissato possiamo calcolare Ak(x) iterativamente con k cicli for annidati: Ak(j) a= j, nk-1= a+1 forik-1= 1to nk-1// calcola Ak-1(a+1)(j) nk-2 = a+1 forik-2= 1to nk-2// calcolaAk-2(a+1)(j) ………… n1= a+1 for i1= 1to n1// calcolaA1(a+1)(j) n0 = a+1 for i0= 1to n0// calcolaA0(a+1)(j) a= a+1 returna

33. Come cresce la funzione di Ackermann? Calcoliamo A1(j) sapendo che A0( j) = j+1 Quindi

34. Calcoliamo A2( j) Quindi

35. Calcoliamo A3(1) e A4(1)

36. La funzione inversa è Il numero stimato di atomi dell’universo è 1080 !!! In ogni applicazione pratica α(n) ≤ 4.