Valutazione di progressioni geometriche

Valutazione di progressioni geometriche
Somme finite: Sia Sn =
Pn
i . Se α 6= 1 allora
α
i=0
Sn (α − 1) = α · Sn − Sn =
n
X
i=0
αi+1 −
= α + α2 + . . . + +αn + α
= αn+1 − 1
n
X
αi
i=0
n+1
− 1 − α − α2 − . . . − αn
da cui Sn = (αn+1 − 1)/(α − 1).
Somme infinite: Supponiamo 0 < α < 1 e sia S =
Allora αS =
P∞
i=1 α
i,
S(1 − α) = S − αS =
P∞
i.
α
i=0
da cui
∞
X
i=0
αi −
∞
X
i=1
αi = α0 = 1, ovvero S = 1/(1 − α)
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 1/22
Esempio
P⌊log3 n⌋
Calcoliamo
P⌊log3 n⌋ 1 i
i=0
P∞
(1/3)i ovviamente vale che
1 i
< i=0 3
Applicando quindi la formula
i=0
3
Sn =
∞
X
αi =
i=0
1
1−α
alla espressione
∞ i
X
1
i=0
3
otteniamo
⌊log3 n⌋ X
i=0
1
3
i
<
∞ i
X
1
i=0
3
1
=
= (3/2)
1 − (1/3)
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 2/22
Parliamo ora di
Analisi di Algoritmi Ricorsivi:
Come esprimere la complessità di algoritmi ricorsivi
mediante relazioni di ricorrenza
Come derivare le relazioni di ricorrenza
Come risolvere le relazioni di ricorrenza
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 3/22
Struttura tipica di algoritmi ricorsivi
Algoritmo A(I)
..
.
A(I1 )
..
.
A(Ia )
..
.
I è l’input iniziale all’algoritmo
..
i puntini " . ” sono istruzioni di qualche tipo
A(I1 ), . . . , A(Ia ) sono le a chiamate ricorsive
all’algoritmo A, rispettivamente sugli input I1 , . . . , Ia .
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 4/22
Derivazione di relazioni di ricorrenza
Per derivare le relazioni di ricorrenza che descrivono il tempo di
esecuzione T (n) di un algoritmo occorre:
Determinare la taglia dell’input n
Determinare quale valore n0 di n è usato per la base della
ricorsione (generalmente, ma non sempre, n0 = 1).
Determinare il valore T (n0 ) del tempo di esecuzione sulla base
della ricorsione (spesso basterà essere certi che T (n0 ) = c, per
qualche costante c)
Il valore T (n) sarà generalmente uguale ad una somma del tipo
T (m1 ) + . . . + T (ma ) (per le chiamate ricorsive), piú la somma di
eventuale altro lavoro fatto. Spesso le a chiamate ricorsive saranno
effettuate tutte su sottoproblemi di taglia uguale f (n), dando un
termine aT (f (n)) nella relazione di ricorrenza.
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 5/22
Tipica relazione di ricorrenza
T (n) =


 c
se n = n0

 aT (f (n)) + g(n) altrimenti
n0 =base ricorsione, c =tempo di esecuzione per la
base
a =numero di volte che le chiamate ricorsive sono
effettuate
f (n) =taglia dei problemi risolti nelle chiamate ricorsive
g(n) =tutto il tempo di calcolo non incluso nelle
chiamate ricorsive
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 6/22
Esempi
procedure bugs(n)
if n = 1 then do qualcosa
else
bugs(n − 1);
bugs(n − 2);
for i = 1 to n do qualcosa


se n = 1
 c
T (n) =

 T (n − 1) + T (n − 2) + cn altrimenti
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 7/22
Esempi
procedure daffy(n)
if n = 1 or n = 2 then do
else
qualcosa
daffy(n − 1);
for i = 1 to n do
qualcosa di nuovo
daffy(n − 1)


se n ≤ 2
 c
T (n) =

 2T (n − 1) + cn altrimenti
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 8/22
Esempi
procedure elmer(n)
if n = 1 then do qualcosa
else if n = 2 then do qualcos’altro
else
for i = 1 to n do
elmer(n − 1)
fa qualcosa di differente


se n ≤ 2
 c
T (n) =

 nT (n − 1) + cn altrimenti
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 9/22
Esempi
procedure bar(n)
if n = 1 then do qualcosa
else
for i = 1 to n do
bar(i)
fa qualcosa di differente


se n = 1
 c
T (n) =

 Pn T (i) + cn altrimenti
i=1
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 10/22
Un teorema generale
Teorema: Se n è potenza di c, la soluzione alla ricorrenza

 d
se n ≤ 1
T (n) =
 aT (n/c) + bn altrimenti
è



 O(n)
T (n) =
O(n log n)



O(nlogc a )
se a
<c
se a
=c
se a
>c
Esempi:
• Se T (n) = 2T (n/3) + dn, allora T (n) = O(n)
• Se T (n) = 2T (n/2) + dn, allora T (n) = O(n log n)
• Se T (n) = 4T (n/2) + dn, allora T (n) = O(n2 )
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 11/22
Cenni di dimostrazione, quando n = ci
T (n)
=
=
=
=
=
a · T (n/c) + bn (per ipotesi)
a(a · T (n/c2 ) + bn/c) + bn
a2 · T (n/c2 ) + abn/c + bn
a2 (a · T (n/c3 ) + bn/c2 ) + abn/c + bn
a3 · T (n/c3 ) + a2 bn/c2 + abn/c + bn
···
=
(in quanto T (n/c) = aT (n/c2 ) + bn/c)
ai T (n/ci ) + bn
i−1
X
(a/c)j
j=0
logc n−1
=
a
logc n
T (1) + bn
X
(a/c)j (poichè i = logc n)
j=0
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 12/22
continuando...
logc n−1
T (n) = a
logc n
X
T (1) + bn
(a/c)j (dalla slide precedente)
j=0
logc n−1
= da
logc n
+ bn
X
(a/c)j (per ipotesi T (1) = d)
j=0
Ricordando che x = y logy x , abbiamo
alogc n = (clogc a )logc n = (clogc n )logc a = nlogc a
e quindi
logc n−1
T (n) = d · n
logc a
+ bn
X
(a/c)j
j=0
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 13/22
Per calcolare
logc n−1
X
(a/c)j
j=0
occorre ricordare ció che abbiamo già visto sulle Progressioni
Geometriche, ovvero:
Somme finite: Se α 6= 1 allora
n
X
i=0
n+1 − 1
α
αi =
α−1
(1)
Somme infinite: Se 0 < α < 1. Allora
∞
X
i=0
αi =
1
1−α
(2)
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 14/22
ritornando alla dimostrazione ...
Caso 1: a < c (cioè (a/c) < 1)
logc n−1
X
j=0
∞
X
c
1
=
(a/c) =
(a/c) <
1 − a/c
c−a
j=0
j
j
(dalla formula (2) precedente)
Pertanto
T (n) < d · nlogc a + bcn/(c − a) = O(n)
(Infatti, a < c ⇒ logc a < 1 e quindi il termine d · nlogc a è O(n))
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 15/22
altro caso...
Caso 2: a = c
Allora
logc n−1
T (n) = d · n
logc a
+ bn
X
(a/c)j
j=0
logc n−1
= d·n
logc a
+ bn
X
(1)j
j=0
= O(n log n)
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 16/22
ed infine ...
Caso 3: a > c (il che implica (a/c) 6= 1)
Dalla precedente formula (1) otteniamo
logc n−1
X
(a/c)
j
=
(a/c)logc n − 1
(a/c) − 1
=
nlogc a−1 − 1
(a/c) − 1
j=0
(poichè alogc n = nlogc a e (1/c)logc n = 1/n)
= O(nlogc a−1 )
Pertanto,
logc n−1
T (n) = d · n
logc a
+ bn
X
(a/c)j = O(nlogc a )
j=0
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 17/22
Qualche noioso dettaglio...
Cosa accade se n NON è potenza di c?
Osserviamo che per k = ⌊logc n⌋ vale che
ck ≤ n < ck+1
e
cn ≥ ck+1
(3)
Immaginiamo quindi di "aumentare" l’input di taglia n, fino a farlo
diventare di taglia ck+1 . É ovvio che T (n) < T (ck+1 ).
Applicando ora il teorema a T (ck+1 ), otteniamo
T (n) < T (ck+1 ) =

k+1

O(c
) = O(cn) = O(n)





se a
<c
O(ck+1 log ck+1 ) = O(cn log(cn)) = O(n log n)
se a
=c
O((ck+1 )logc a ) = O((cn)logc a ) = O(nlogc a )
se a
>c
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 18/22
Esempi
Sia T (1) = 1. Valutiamo
• T (n) = 2T (n/2) + 6n
T (n) = O(n log n)
• T (n) = 3T (n/3) + 6n − 9
• T (n) = 2T (n/3) + 5n
T (n) = O(n log n)
T (n) = O(n)
• T (n) = 2T (n/3) + 12n + 16
• T (n) = 4T (n/2) + n
• T (n) = 3T (n/2) + 9n
T (n) = O(n)
T (n) = O(nlog2 4 ) = O(n2 )
T (n) = O(nlog2 3 ) = O(n1.584... )
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 19/22
Concludendo
Con esattamente la stessa tecnica è possibile dimostrare una
forma un pó piú generale del Teorema, ad esempio la seguente:
Teorema: La soluzione alla ricorrenza

 d
se n ≤ 1
T (n) =
 aT (n/c) + bnk altrimenti
per a, c, b, k costanti, è


k)
k

O(n
se
a
<
c


T (n) =
O(nk log n) se a = ck



 O(nlogc a )
se a > ck
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 20/22
Altri esempi
Sia T (1) = 1. Valutate
• T (n) = 2T (n/2) + n3
T (n) = O(n3 )
• T (n) = T (9n/10) + n
T (n) = O(n)
• T (n) = 16T (n/4) + n2
T (n) = O(n2 log n)
• T (n) = 7T (n/3) + n2
T (n) = O(n2 )
• T (n) = 7T (n/2) + n2
√
• T (n) = 2T (n/3) + n
T (n) = O(nlog2 7 )
• T (n) = T (n − 1) + n
√
• T (n) = T ( n) + 1
T (n) = O(?)
T (n) = O(nlog3 2 )
T (n) = O(?)
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 21/22
Infine
Esistono forme ancora piú generali del Teorema, che permettono la
risoluzione di equazioni di ricorrenza del tipo generale
T (n) = aT (n/b) + f (n)
Sussiste il seguente risultato
1.Se f (n) = O(nlogb a−ǫ ), per qualche ǫ > 0, allora T (n) = Θ(nlogb a )
2. Se f (n) = Θ(nlogb a ), allora T (n) = Θ(nlogb a log n)
3. Se f (n) = Ω(nlogb a+ǫ ), per qualche ǫ > 0, e se af (n/b) ≤ cf (n)
per qualche costante c > 1 ed n sufficientemente grande, allora
T (n) = Θ(f (n))
Universitá degli Studi di Salerno – Corso di Introduzione agli Algoritmi e Strutture Dati – Prof. Ugo Vaccaro – Anno Acc. 2015/16 – p. 22/22