Di cosa parliamo oggi?

Transcript

1 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 1/41 Di cosa parliamo oggi? Oggi parliamo di Analisi di Algoritmi Analisi di Algoritmi = valutazione delle risorse usate da algoritmi per risolvere un dato problema Risorse = Tempo impiegato dall algoritmo Memoria usata dall algoritmo Tipicamente analizzeremo gli algoritmi in termini del tempo di esecuzione da loro impiegato per produrre l output richiesto.

2 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 2/41 In pratica, il tempo di esecuzione dipende (anche) dall implementazione Schema di Implementazione di Algoritmi Algoritmo Programmatore Programma Compilatore Eseguibile Calcolatore

3 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 3/41 Il tempo di esecuzione dipende quindi... Dall abilità del programmatore e dal linguaggio di programmazione usato Dal linguaggio macchina del computer Dal codice che il compilatore genera Dalla taglia del problema (=la dimensione" dell input) Da come é fatto l input (ad es., ordinato/non-ordinato) Dal numero di operazioni elementari eseguite dall algoritmo

4 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 4/41 Quindi... Quantificheremo le risorse usate da un algoritmo a meno di una costante moltiplicativa (useremo quindi le notazioni asintotiche O, Θ e Ω). Perchè? Perchè le costanti moltiplicative dipendenti dai primi 3 aspetti prima enunciati non sono a priori quantificabili, in quanto dipendono da aspetti a noi ignoti Inoltre, per input molto grandi (il che corrisponde a situazioni pratiche) l influenza che tali costanti hanno sul reale tempo di esecuzione di un algoritmo è minore

5 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 5/41 Operazioni elementari Misureremo la complessità di un algoritmo in termini del numero di operazioni elementari usate Esempi di operazioni elementari: addizione e moltiplicazione di numeri (se piccoli...), confronto tra elementi, seguire un puntatore... Si assume che le operazioni elementari richiedano un tempo costante per la loro esecuzione (=una unità di tempo)

6 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 6/41 La taglia dell input Il tempo di esecuzione di un algoritmo in generale dipende quanto grande è l input (taglia dell input). Ma cosa intendiamo esattamente per taglia dell input? Criterio di costo logaritmico: la taglia dell input è il numero di bits necessari per rappresentarlo Criterio di costo uniforme: la taglia dell input è il numero di "elementi" che lo costituiscono Nell ipotesi che ogni istruzione del computer richieda un unità di tempo e che un numero o "elemento" richieda una parola di memoria, le due misure coincidono a meno di una costante moltiplicativa

7 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 7/41 Esempi Problema taglia dell input operazione elementare Trovare x in una lista # di elementi della lista confronto tra elementi Moltiplicazione di matrici dimensione delle matrici moltiplicazione di due numeri Ordinamento di un array # di elementi dell array confronto tra elementi Visita di un albero/grafo #numero di nodi/archi seguire un puntatore Moltiplicazione di due numeri # bits per rappresentarli addizione/sottrazione Nell ultimo caso della moltiplicazione di due numeri abbiamo usato il criterio di costo logaritmico per misurare la taglia dell input, nei primi quattro casi abbiamo usato il criterio di costo uniforme.

8 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 8/41 Anche la forma dell input influenza la complessità La complessità di un algoritmo puó dipendere anche da come è fatto l input (ad es., ordinare n elementi puó essere fatto piú velocemente se essi sono già (quasi) ordinati) Useremo come strumento di analisi il caso peggiore, inteso come il tempo usato dall algoritmo nella situazione piú "sfavorevole" in input. La complessità di tempo di un algoritmo A, su input di taglia n, che denoteremo con T(n) sarà quindi T(n) = il massimo tempo richiesto da A, dove il massimo è calcolato su tutti i possibili input di taglia n Ció ci darà un limite superiore alla complessità dell algoritmo, su tutti i possibili input (nel senso che A non richiederà mai tempo superiore a T(n) su di un input di taglia n.

9 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 9/41 Quindi, ad esempio, se diciamo che... la complessità T(n) di un algoritmo A è O(n 2 ), vuol dire che A non richiede mai tempo superiore a cn 2, per produrre il suo output in corrispondenza ad un qualsivoglia input di taglia n, per c opportuna e n sufficientemente grande. la complessità T(n) di un algoritmo A è Ω(n 2 ), vuol dire che A richiede almeno tempo cn 2, per produrre il suo output nel caso peggiore, per c opportuna e n sufficientemente Quindi NON si intende dire che A impiega tempo cn 2, su ogni input di taglia n, ma nel secondo caso si intende che ESISTE almeno un input di taglia n (n suff. grande) su cui A richiede tempo cn 2 (e nel primo caso si intende che NON esistono input per cui l algoritmo richiede tempo > cn 2 ). (Ad es., la ricerca sequenziale di un elemento x in una lista richiede O(n) e Ω(n) nel caso peggiore, ma se x è il primo elemento della lista, richiede O(1))

10 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 10/41 Esempio ALG(n) 1. if n è pari 2. then return(0) 3. else 4. for i = 1 to n do 5. x = x+1 La complessità dell algoritmo nel caso peggiore è Θ(n). Possiamo dire che l algoritmo esegue Θ(n) passi per ogni input? No! Infatti esise un numero infinito di input su cui l algoritmo esegue un solo passo. Ció che possiamo dire è che l algoritmo non esegue mai piú di O(n) passi per ogni input, e che esegue almeno n passi per certi input.

11 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 11/41 Calcolo della complessità di tempo Effettueremo quasi esclusivamente analisi nel caso peggiore, usando le seguenti regole: il costo di istruzioni semplici, quali assegnazione, letture/scrittura di variabili è O(1) il costo di istruzioni tipo if... then...else è pari al tempo per effettuare il test (tipicamente O(1)) piú O(costo della alternativa piú costosa) il costo di loop (for, while, repeat) è pari alla somma su tutte le iterazioni del costo di ogni iterazioni Usando queste regole si puó ottenere la complessità di tempo di ogni algoritmo (ad eccezione degli algoritmi ricorsivi, che richiedono una tecnica diversa)

12 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 12/41 Un pó di preliminari Quant è Valutiamo 2 k i=1 i: k i=1 i? 2 k i=1 i = (k 1)+ k +k + (k 1)+(k 2) = (k +1)+(k +1)+(k +1)+...+(k +1)+(k +1) = k(k +1) da cui k i=1 i = k(k +1) 2

13 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 13/41 Esercizi Usando la notazione Θ, stimare il numero di volte che la istruzione x = x+1 viene eseguita: 1. for i = 1 to 2n x = x+1 Θ(n) 2. for i = 1 to 2n for j = 1 to n x = x+1 Θ(n 2 ) 3. for i = 1 to n for j = 1 to i for k = 1 to j x = x+1 n i=1 i j=1 j = n i=1 i(i+1) 2 = Θ(n 3 )

14 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 14/41 Prova che n i=1 i(i+1) 2 = Θ(n 3 ) Poichè n i=1 i(i+1) 2 = 1 2 ( n i 2 + i=1 ) n i i=1 = 1 2 ( n i=1 ) i 2 + n(n+1) 2 basterà provare che n i=1 i2 = Θ(n 3 ) Ovviamente abbiamo che n i=1 i2 = n 2 n n 2, il che prova n i=1 i2 = O(n 3 ). Abbiamo anche che n i=1 i2 = n 2 ( ) n 2 ( 2 + n 2 +1) n 2 il che prova n i=1 i2 = Ω(n 3 ). ( n 2 )2 n 2 = (n3 8 )

15 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 15/41 Esercizi 4. i = n while i 1 do x = x+1, i = i/2 dopo che il while è eseguito k volte, l indice i vale n/2 k, pertanto il ciclo viene eseguito t volte, dove t è tale che n/2 t = 1, da cui la complessità dell algoritmo è Θ(log n)

16 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 16/41 Esercizi 5. j = n while j 1 do for i = 1 to j x = x+1, j = j/3 6. i = n while i 1 do for j = 1 to n x = x+1, i = i/2 7. i = 2 while i < n do i = i i x = x+1 n+n/3+n/ n/3 log 3 n = n log 3 n i=0 (1/3) i = Θ(n) Θ(nlogn) Θ(loglogn)

17 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 17/41 Esercizi Alg(A[1...n]) 1. for i = 1 to n do 2. B[i] = A[i] 3. for i = 1 to n do 4. j = n 5. while j > i do 6. B[i] = B[i]+A[i],j = j 1 7. for i = 1 to n do 8. t = t+b[i] Analisi: Le linee 1. e 2. prendono tempo Θ(n). Le linee da 3. a 6. prendono tempo n+n = Θ(n 2 ). Le linee 7. e 8. prendono tempo Θ(n). In totale, la complessità dell algoritmo è T(n) = Θ(n)+Θ(n 2 )+Θ(n) = Θ(n 2 )

18 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 18/41 Esercizi PROCEDURA(A[1...n], k] s = 0 for i = 1 to k do s = s+a[i] s = s/k MAIN(AA[1...m]) i = m while i 1 do PROCEDURA(A[1...m], i] i = i 2 Analisi: La complessità dell algoritmo MAIN è Θ(m) +Θ(m 2) +Θ(m 4) +...+Θ(1) = Θ(m 2 )

19 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 19/41 Esempio: moltiplicazione di numeri interi function multiply(y, z) 1. x 0 2. while z > 0 do 3. if z è dispari then x x+y 4. y 2y; z z/2 5. return(x) Supponiamo che z e y siano numeri di n bits. Le istruzioni 1, 3, e 4 costano O(1) ciascuna Il loop while costa O(n) (viene eseguito al piú n volte, ed ogni esecuzione costa O(1)) In totale, la complessità dell algoritmo è quindi O(n)

20 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 20/41 Parentesi: valutazione di progressioni geometriche Somme finite: Sia S n = n i=0 αi. Se α 1 allora S n (α 1) = α S n S n = n α i+1 i=0 n i=0 = α+α α n +α n+1 1 α α 2... α n = α n+1 1 da cui S n = (α n+1 1)/(α 1). Somme infinite: Supponiamo 0 < α < 1 e sia S = i=0 αi. Allora αs = i=1 αi, da cui α i S(1 α) = S αs = α i i=0 α i = α 0 = 1, ovvero S = 1/(1 α) i=1

21 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 21/41 Esempio Per quanto riguarda la espressione log 3 n i=0 (1/3) i ovviamente vale che log 3 n ( 1 ) i i=0 3 < ( 1 i i=0 3) Applicando quindi la formula S n = i=0 α i = 1 1 α alla espressione otteniamo log 3 n i=0 ( ) 1 i < 3 i=0 i=0 ( ) 1 i 3 ( ) 1 i = (1/3) = (3/2)

22 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 22/41 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

23 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 23/41 Struttura tipica di algoritmi ricorsivi Algoritmo A(I). A(I 1 ). A(I a ) I è l input iniziale all algoritmo. i puntini ". sono istruzioni di qualche tipo A(I 1 ),...,A(I a ) sono le a chiamate ricorsive all algoritmo A, rispettivamente sugli input I 1,...,I a.

24 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 24/41 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 n 0 di n è usato per la base della ricorsione (generalmente, ma non sempre, n 0 = 1). Determinare il valore T(n 0 ) del tempo di esecuzione sulla base della ricorsione (spesso basterà essere certi che T(n 0 ) = c, per qualche costante c) Il valore T(n) sarà generalmente uguale ad una somma del tipo T(m 1 )+...+T(m a ) (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.

25 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 25/41 Tipica relazione di ricorrenza T(n) = c sen = n 0 at(f(n))+g(n) altrimenti n 0 =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

26 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 26/41 Esempi procedure bugs(n) if n = 1 then do qualcosa else bugs(n 1); bugs(n 2); for i = 1 to n do qualcosa T(n) = c sen = 1 T(n 1)+T(n 2)+cn altrimenti

27 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 27/41 Esempi procedure daffy(n) if n = 1 or n = 2 then do qualcosa else daffy(n 1); for i = 1 to n do qualcosa di nuovo daffy(n 1) T(n) = c sen 2 2T(n 1)+cn altrimenti

28 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 28/41 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 T(n) = c sen 2 nt(n 1)+cn altrimenti

29 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 29/41 Esempi procedure bar(n) if n = 1 then do qualcosa else for i = 1 to n do bar(i) fa qualcosa di differente T(n) = c sen = 1 n i=1 T(i)+cn altrimenti

30 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 30/41 Un teorema generale Teorema: Se n è potenza di c, la soluzione alla ricorrenza T(n) = d sen 1 at(n/c) + bn altrimenti è T(n) = O(n) sea < c O(nlogn) sea = c O(n log c a ) sea > 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(nlogn) Se T(n) = 4T(n/2)+dn, allora T(n) = O(n 2 )

31 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 31/41 Cenni di dimostrazione, quando n = c i T(n) = a T(n/c)+bn (per ipotesi) = a(a T(n/c 2 )+bn/c)+bn (in quanto T(n/c) = at(n/c 2 )+bn/c) = a 2 T(n/c 2 )+abn/c+bn = a 2 (a T(n/c 3 )+bn/c 2 )+abn/c+bn = a 3 T(n/c 3 )+a 2 bn/c 2 +abn/c+bn i 1 = a i T(n/c i )+bn (a/c) j = a log c n T(1)+bn j=0 log c n 1 j=0 (a/c) j (poichè i = log c n)

32 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 32/41 continuando... T(n) = a log c n T(1)+bn = da log c n +bn log c n 1 j=0 log c n 1 j=0 (a/c) j (dalla slide precedente) (a/c) j (per ipotesi T(1) = d) Ricordando che x = y log y x, abbiamo a log c n = (c log c a ) log c n = (c log c n ) log c a = n log c a e quindi T(n) = d n log c a +bn log c n 1 j=0 (a/c) j

33 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 33/41 Per calcolare log c n 1 j=0 (a/c) j occorre ricordare ció che abbiamo già visto sulle Progressioni Geometriche, ovvero: Somme finite: Se α 1 allora n i=0 α i = αn+1 1 α 1 (1) Somme infinite: Se 0 < α < 1. Allora i=0 α i = 1 1 α (2)

34 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 34/41 ritornando alla dimostrazione... Caso 1: a < c (cioè (a/c) < 1) log c n 1 j=0 (a/c) j < (a/c) j = j=0 1 1 a/c = c c a Pertanto (dalla formula (2) precedente) T(n) < d n log c a +bcn/(c a) = O(n) (Infatti, a < c log c a < 1 e quindi il termine d n log c a è O(n))

35 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 35/41 altro caso... Caso 2: a = c Allora T(n) = d n log c a +bn = d n log c a +bn = O(nlogn) log c n 1 j=0 log c n 1 j=0 (a/c) j (1) j

36 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 36/41 ed infine... Caso 3: a > c (il che implica (a/c) 1) Dalla precedente formula (1) otteniamo log c n 1 j=0 Pertanto, (a/c) j = (a/c)log c n 1 (a/c) 1 = nlog c a 1 1 (a/c) 1 (poichè a log c n = n log c a e (1/c) log c n = 1/n) = O(n log c a 1 ) T(n) = d n log c a +bn log c n 1 j=0 (a/c) j = O(n log c a )

37 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 37/41 Qualche noioso dettaglio... Cosa accade se n NON è potenza di c? Osserviamo che per k = log c n vale che c k n < c k+1 e cn c k+1 (3) Immaginiamo quindi di "aumentare" l input di taglia n, fino a farlo diventare di taglia c k+1. É ovvio che T(n) < T(c k+1 ). Applicando ora il teorema a T(c k+1 ), otteniamo O(c k+1 ) = O(cn) = O(n) sea < c T(n) < T(c k+1 ) = O(c k+1 logc k+1 ) = O(cnlog(cn)) = O(nlogn) sea = c O((c k+1 ) log c a ) = O((cn) log c a ) = O(n log c a ) sea > c

38 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 38/41 Esempi Sia T(1) = 1. Valutiamo T(n) = 2T(n/2)+6n T(n) = 3T(n/3)+6n 9 T(n) = 2T(n/3)+5n T(n) = O(nlogn) T(n) = O(nlogn) T(n) = O(n) T(n) = 2T(n/3)+12n+16 T(n) = O(n) T(n) = 4T(n/2)+n T(n) = O(n log 2 4 ) = O(n 2 ) T(n) = 3T(n/2)+9n T(n) = O(n log 2 3 ) = O(n )

39 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 39/41 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 sen 1 T(n) = at(n/c)+bn k altrimenti per a,c,b,k costanti, è T(n) = O(n k ) sea < c k O(n k logn) sea = c k O(n log c a ) sea > c k

40 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 40/41 Altri esempi Sia T(1) = 1. Valutate T(n) = 2T(n/2)+n 3 T(n) = O(n 3 ) T(n) = T(9n/10)+n T(n) = 16T(n/4)+n 2 T(n) = O(n) T(n) = O(n 2 logn) T(n) = 7T(n/3)+n 2 T(n) = O(n 2 ) T(n) = 7T(n/2)+n 2 T(n) = O(n log 2 7 ) T(n) = 2T(n/3)+ n T(n) = O(n log 3 2 ) T(n) = T(n 1)+n T(n) = T( n)+1 T(n) = O(?) T(n) = O(?)

41 Universitá degli Studi di Salerno Corso di Algoritmi Prof. Ugo Vaccaro Anno Acc. 2014/15 p. 41/41 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(n log b a ǫ ), per qualche ǫ > 0, allora T(n) = Θ(n log b a ) 2. Se f(n) = Θ(n log b a ), allora T(n) = Θ(n log b a logn) 3. Se f(n) = Ω(n log b 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))