Complessità ammortizzata degli algoritmi Union Find

Presentazione sul tema: "Complessità ammortizzata degli algoritmi Union Find"— Transcript della presentazione:

1 Complessità ammortizzata degli algoritmi Union Find
Lezione n°9 Prof.ssa Rossella Petreschi Lezione del 5 /11/ del Corso di Algoritmica

2 A proposito del rank rank = 0
per ogni nuovo nodo creato da una operazione di makeset rank = rank + 1 dopo una union di due insiemi con radici dello stesso rank e fintantoche x è radice rank(x) rimane invariato non appena x cessa di essere radice rank(x)≤ rank(p(x))≤ logn e #nodi in T(x)=size(x) ≥ 2rank(x) 2

3 Quanti nodi hanno rank pari ad r?
Lemma: Durante l’esecuzione di una sequenza di makeset, union e find al più n/2r nodi possono avere rank uguale ad r Per la proprietà 2), quando si assegna rank(x) = r vuol dire che è stata appena effettuata una operazione di union ed x è diventata radice di un qualche albero con almeno 2r nodi (proprietà 4). Conseguentemente almeno 2r nodi saranno etichettati x(r). Se x non sarà più radice, finirà in un albero di rank almeno r+1 (proprietà 2) Visto che ci sono in totale n nodi ne segue che non sarà mai possibile avere più di n/ 2r nodi di rank r 3

4 log*n e F(i) log*n = min i (log(i)n )≤1
log(1)n = logn e …. log(i)n = log(log(i-1)n )= loglog….logn (i volte) F (i) = 2F(i-1) se i ≥ 1; F(0) = 1 F(0) = 1 log*x = < x ≤ 1 F(1) = 2 log*x = < x ≤ 2 F(2) = 4 log*x = < x ≤ 4 F(3) = 16 log*x = < x ≤ 16 F(4) = log*x = < x ≤ 65536 F(5) = log*x = < x ≤ 4

5 Partizionamento dei nodi in blocchi
Come conseguenza del Lemma appena visto possiamo partizionare i nodi in blocchi nel seguente modo: se un nodo v ha rank r, allora appartiene al blocco B(log*r). Poichè rank ≤ logn, allora #blocchi ≤ log*(logn), da cui: B(0) contiene nodi di rank in [0,1], ovvero [0,F(0)] B(1) contiene nodi di rank in [2,2], ovvero [F(0) +1, F(1)] B(2) contiene nodi di rank in [3,4], ovvero [F(1) +1, F(2)] ………………………………… B(i) contiene nodi di rank in [F(i-1) +1, F(i)] ……………………… B(log*n-1) contiene nodi di rank in [F(log*n -2) +1, F(log*n-1)] In ogni blocco ci saranno al più un numero di rank diversi ≤ F(i) - F(i-1) ≤ F(i) 5

6 Tempo O((n+m)log*n) Raffiniamo l’assegnazione dei crediti: (1+log*n), 1 e (1+log*n), ad ogni operazione di makeset, union e find, rispettivamente,da cui: n(1+log*n) + (n-1) + m(1+log*n) = O((n+m) log*n) Come nella prova precedente, sia il cammino visitato dalla find (il cammino si suppone di l nodi). I crediti assegnati alla find servono questa volta per pagare i costi per la visita della radice, del figlio della radice e di tutti i nodi in  che non sono nello stesso blocco del loro padre. I costi relativi ad ogni altro nodo x di  (ovvero ad ogni altro nodo nello stesso blocco del padre) vengono pagati con i crediti che makeset immagazzina in x. Resta da vedere che i crediti così assegnati siano sufficienti. 6

7 I crediti assegnati alla find sono sufficienti
Poichè ci sono log*n blocchi distinti, per ogni find ci sono al più log*n-1 nodi in un blocco diverso da quello del loro padre. Quindi i crediti assegnati alla find sono sufficienti per soddisfare la richiesta di log*n-1+2= log*n+1 nodi. 7

8 I crediti assegnati alla makeset sono sufficienti
Il numero di crediti immagazzinato dalle n operazioni makeset è sufficiente perché si ha che: ogni nodo nel blocco richiede al più F(i) crediti; ci sono al più n/F(i) nodi nel blocco B(i) per 0 ≤ i ≤ log*n -1. Prova di 1. Ogni nodo in un generico blocco B(i) può chiedere al più F(i) crediti, dato che ogni volta che richiederà un credito il rank di suo padre dovrà aumentare e nel blocco B(i) ci sono al più F(i) - F(i-1) ≤ F(i) valori diversi del rank 8

9 ci sono al più n/F(i) nodi nel blocco B(i)
Prova di 2. (n/2r) per (F(i-1) +1 ≤ r ≤ F(i)) = (n/2r) per 0 ≤ r ≤ F(i)) - (n/2r) per 0 ≤ r ≤ F(i-1) +1 )= = n(1/2) F(i) +1 -1 / (1/2-1) - n(1/2) F(i-1) +2-1 / (1/2-1)≤ ≤ n (1/2) F(i-1) +1 - (1/2) F(i) +1  / 1/2  ≤ n (1/2) F(i-1) +1  / 1/2  ≤ n /2F(i-1) = n /F(i) 9

10 Il risultato migliore Una qualunque sequenza di n operazioni makeset, m operazioni find e al più (n-1) operazioni union può essere realizzata in tempo O(n+m(m+n,n) funzione di Ackermann A(1,j) = 2j j≥1 A(i,1) = A(i-1,2) per i≥2 A(i,j) = A(i-1, A(i,j-1) per i,j≥2 funzione inversa della funzione di Ackermann 10

11 Numeri di Catalano Il numero di alberi binari distinti con n nodi è pari al numero di Catalano di dimensione n: Cn = (2n su n)/(n+1), risultato dell’equazione ricorsiva Cn = ∑ Cs Cn-s-1, con 0 ≤ s ≤ n-1 e C0= C1=1 C2= 2 C3= 5 C4= 14 C5= 42 …………. 11

12 Quanti bit per un albero binario?
Per rappresentare un qualunque albero binario con n nodi occorrono un numero di bit pari a log Cn= log[(2n su n)/ (n+1)] > > log[(22n)/ (2n(n+1))] per la (*) = 2n - O(logn) (*) (2n su n) = (2n)!/n! (2n-n)! = = (2n/2n) [2n (2n-1) (2n-2)…….1]/[n(n-1)(n-2)…1] [n(n-1)(n-2)…1]) = = (1/2n)[(2n2n)/(nn)][(2n-1)(2n-2)/(n-1)(n-1)]… [3x2/1] > > (1/2n)[(22n2/n2)][(2n-2)(2n-2)/(n-1)(n-1)]… [2x2/1] = = (1/2n) [22n2/n2] [22(n-1)2 /(n-1)2]… [22/12] = (1/2n) x (22n) 12