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 {S1, …, Sk} (S) t.c.

1. S = S1 … Sk

2. se i j allora Si Sj =

Ai fini pratici è conveniente identificare ciascun elemento non vuoto Si della partizione con un suo elemento a Si, detto rappresentante canonico di Si.

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} }

a b c d

e f ge S2

a S1

AlgoLab - Insiemi disgiunti

Analisi dei costi

Dopo q unioni su una struttura di n nodi:1. Create è (n)

2. Union è (q2) ovvero

i=1q-1 i = (q2)

Posto m = n + q, essendo n = (m) e q = (m) il tempo richiesto è (m2) (il tempo ammortizzato di un’operazione è dunque (m)).

AlgoLab - Insiemi disgiunti

Realizzazione con foreste

a

b d

c

e

f

g

P = {{a, b, c, d} , {e, f, g}}

a S1 e S2

AlgoLab - Insiemi disgiunti

Unione

e

f

g

Union(P, a, e) = {{a, b, c, d, e, f, g}}

a

b d

c

a

b d

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

yLink(x, y) =

AlgoLab - Insiemi disgiunti

Nuova analisi di Find (1)

Teorema. Se Union è implementata con l’euristica Unione-per-peso, allora per ogni x:

2rank(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 20 = 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) + 1

2rank(n+1,x) = 2rank(n,y)+1

= 2rank(n,y) + 2rank(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.

ab

cd

a b c

d

Nota: Un confine superiore all’analisi ammortizzata di m operazioni su un insieme di n elementi è O(m lg* n).

AlgoLab - Insiemi disgiunti

AlgoLab - Insiemi disgiunti

Realizzazione in Java