AlgoLab - Insiemi disgiunti Insiemi disgiunti Laboratorio di Algoritmi 02/03 Prof. Ugo de’ Liguoro

AlgoLab - Insiemi disgiunti Partizioni Def. Una partizione (finita) di un’insieme S è un sottoinsieme {S 1, …, S k }  (S) t.c. 1. S = S 1  …  S k 2. se i  j allora S i  S j =  Ai fini pratici è conveniente identificare ciascun elemento non vuoto S i della partizione con un suo elemento a  S i, detto rappresentante canonico di S i.

AlgoLab - Insiemi disgiunti L’ADT Disjoint-set datatype Disjoint_Set, Set, T; constructors: Create: Set -> Disjoint_Set; Union: Disjoint_set,T,T -> Disjoint_Set; observation: Find: Disjoint_Set,T -> T; semantics: Create(S) ritorna la partizione P di S t.c. ogni elemento di P e' un singoletto Union(P,x,y) ritorna la partizione che si ottiene da P rimpiazzando gli insiemi di cui x e y sono rappresentanti con la loro unione Find(P,a) ritorna il rappresentante dell’elemento di P cui a appartiene (pre: a in Unione(P))

AlgoLab - Insiemi disgiunti Realizzazione con liste { {a, b, c, d}, {e, f, g} } abcdefg e  S2e  S2 a  S1a  S1

AlgoLab - Insiemi disgiunti Analisi dei costi Dopo q unioni su una struttura di n nodi: 1. Create è  (n) 2. Union è  (q 2 ) ovvero  i=1 q-1 i =  (q 2 ) Posto m = n + q, essendo n =  (m) e q =  (m) il tempo richiesto è  (m 2 ) (il tempo ammortizzato di un’operazione è dunque  (m)).

AlgoLab - Insiemi disgiunti Realizzazione con foreste a bd c e f g P = {{a, b, c, d}, {e, f, g}} a  S1a  S1 e  S2e  S2

AlgoLab - Insiemi disgiunti Unione e f g Union(P, a, e) = {{a, b, c, d, e, f, g}} a bd c a bd c e f g  

AlgoLab - Insiemi disgiunti Euristiche: unione per peso Def. Sia T il sottoalbero con root(T) = x: weight(x) = card(T), rank(x) = height(T). Euristica Unione-per-peso: Link(x, y)se weight(x)  weight(y) Union(P, x, y) = Link(y, x)altrimenti Dove x y Link(x, y) =

AlgoLab - Insiemi disgiunti Nuova analisi di Find (1) Teorema. Se Union è implementata con l’euristica Unione- per-peso, allora per ogni x: 2 rank(x)  weight(x), quindi se n = card(T) con root(T) = x, allora rank(x)  lg n, ossia Find è  (lg n). Dim. Per induzione sulle chiamate successive di Union. Denotiamo con rank(n, x) = rank(x) dopo n applicazioni di Union alla partizione discreta (tutti singoletti); analogamente weight(n, x), Union(n, x, y) e height(n, x): facciamo dunque induzione su n.

AlgoLab - Insiemi disgiunti Nuova analisi di Find (2) Base: se n = 0 allora rank(n, x) = 0, e 2 0 = 1 = weight(n, x); Passo: supponiamo che weight(n, x) > weight(n, y) per cui Union(x, y) = Link(y, x); due sottocasi: a) height(n, x) > height(n, y): allora rank(n+1,x) = rank(n,x) b) height(n, x) = height(n, y): allora rank(n+1, x) = rank(n, y) rank(n+1,x) = 2 rank(n,y)+1 = 2 rank(n,y) + 2 rank(n,y)  weight(n, y) + weight(n, y) (ip. ind.)  weight(n, x) + weight(n, y) = weight(n+1, x)

AlgoLab - Insiemi disgiunti Euristiche: unione per rango Euristica Unione-per-rango: Link(x, y)se rank(x)  rank(y) Union(P, x, y) = Link(y, x)altrimenti Si può dimostrare che anche con questa euristica Find è  (lg n). Link-by-rank (x, y) 1.if rank[x] > rank[y] 2. then parent[y] := x 3. else parent[x] := y 4. if rank[x] = rank[y] 5. then rank[y] := rank[y] + 1

AlgoLab - Insiemi disgiunti Euristiche: compressione del cammino Euristica: nel calcolare Find(P, a), rendiamo ogni vertice incontrato sul cammino da a alla radice dell’albero cui appartiene, figlio di questa radice. a b c d abc d Nota: Un confine superiore all’analisi ammortizzata di m operazioni su un insieme di n elementi è O(m lg* n).

AlgoLab - Insiemi disgiunti

Realizzazione in Java