Per regnare occorre tenere divisi i nemici e trarne vantaggio. fai ad ogni passo la scelta più conveniente

Transcript

1 Progetto di algoritmi sequenziali (un solo esecutore ) Divide et Impera Per regnare occorre tenere divisi i nemici e trarne vantaggio Greedy fai ad ogni passo la scelta più conveniente Buoni risultati immediati possono dare buoni risultati anche a lungo termine

2 Backtrack Prova a fare qualche cosa; se non funziona, disfala e prova qualcos altro Programmazione dinamica Filosofia Divide et Impera portata all estremo: se non si sa quali sottoproblemi risolvere, si può provare a risolverli tutti e conservare i risultati per poterli usare successivamente per risolvere il problema di dimensioni più grandi Ricerca locale Pianifica il metodo di soluzione del problema in modo che sia applicabile dinamicamente a dati di dimensione via via crescente Non guardare più in là del proprio orto

3 Algoritmi di approssimazione Per molti problemi di ottimizzazione c è poca speranza di progettare un algoritmo che trovi la soluzione ottima con complessità polinomiale. In tali casi, comunque, ci si può spesso accontentare di una soluzione che sia abbastanza vicina a quella ottima. Algoritmi probabilistici La computazione dipende dai valori prodotti da un generatore di numeri casuali

4 Algoritmi euristici Forniscono una soluzione ammissibile, non necessariamente ottima nè approssimata. Spesso basati su tecniche greedy o di ricerca locale Algoritmi paralleli (più di un esecutore )

5 Divide et impera (Divide and Conquer) Dividi il problema in sottoproblemi piu` semplici e risolvili ricorsivamente

6 Divide et impera - Schema generale Divide-et-impera (P, n) if n k then risolvi direttamente else dividi P in sottoproblemi P 1, P 2,,P h di dimensione n 1, n 2,, n h risp. for i 1 to h do Divide-et-impera (P i, n i ) combina i risultati di P 1,, P h per ottenere quello di P

7 Divide et impera - Complessità Il costo dell algoritmo è di solito costante per i casi in cui la soluzione viene costruita direttamente; per i casi in cui non è immediata, il costo può essere espresso come somma di h + 2 costi: il costo di dividere il problema nei sottoproblemi il costo di combinare i risultati dei sottoproblemi per ottenere il risultato del problema gli h costi delle soluzioni dei sottoproblemi T(n) = c n k = D(n) + C(n) + Σ i=1..h T(n i ) n > k

8 Problema: è relativamente semplice esprimere la complessità con una relazione di ricorrenza, è però piuttosto complicato risolvere la relazione di ricorrenza per trovare la complessità asintotica. Ci sono tre modi per trovare la soluzione: metodo di sostituzione metodo iterativo metodo principale

9 Il metodo di sostituzione Ipotizza un limite asintotico verifica l ipotesi con una dimostrazione per induzione esempio: T(n) = 4T(n/2) + n possiamo provare T(n) = O(n 3 ) mostriamo che esistono c ed n 0 : T(n) c n 3 per tutti gli n n 0 Supponendo T(k) c k 3 per tutti i k < n, si ottiene T(n) = 4T(n/2) + n 4c(n/2) 3 + n = cn 3 - (c/2 n 3 - n) cn 3 per c 2 e n 1 Anche T(1) deve essere c 1 3

10 un tentativo migliore: T(n) = O(n 2 ) Cerchiamo di dimostrare che T(n) c n 2 per tutti gli n n 0 Supponendo T(k) c k 2 per tutti i k < n, si ottiene T(n) = 4T(n/2) + n 4c(n/2) 2 + n = cn 2 + n cn 2 per nessun c 0 Dobbiamo modificare l ipotesi: T(n) c n 2 - d n, d 1 T(n) = 4T(n/2) + n 4 (c(n/2) 2 - d(n/2)) + n = cn 2-2dn + n = cn 2 - dn - (dn - n) cn 2 - dn Si può scegliere d = 1.

11 Bisogna fare attenzione alle condizioni al contorno. Non è sempre scontato che esse siano limitate da c f(n). Ad esempio supponiamo di aver dimostrato per la ricorrenza T(n) = 2 T(ºn/2ß) + n che T(n) c n lgn e sia T(1) = 1 Allora non si ottiene T(1) c 1 lg1 per nessun c, essendo lg1 = 0 La difficoltà può essere superata ricordando che la notazione asintotica richiede di dimostrare T(n) c n lgn per gli n n 0, dove n 0 è una costante. Consideriamo allora T(2) e T(3), in quanto per n > 3, la relazione non dipende più da T(1). T(2) = 4 c 2 lg2 T(3) = 5 c 3 lg3 Basta scegliere c 2

12 Un inconveniente del metodo di sostituzione è che non esiste una regola per trovare la soluzione corretta per ogni ricorrenza. Di solito bisogna provare più tentativi, ma se la ricorrenza è simile ad una di cui si conosce la soluzione, si può provare la stessa soluzione. Ad esempio: T(n) = 2T( n/2 + 15) + n Intuitivamente per n grande la differenza tra n/2 e n/ non è molto significativa. Si può perciò tentare con la soluzione T(n) = O(n lgn), che sappiamo risolvere la ricorrenza T(n) = 2T( n/2 ) + n.

13 Dimostriamo il risultato anticipato prima che la ricorrenza T(n) = 2T (ºn/2ß) + n appartiene all insieme O(n lgn) Proviamo T(n) c n lgn T(n) = 2T (ºn/2ß) + n ( ºn/2ß n/2 ) 2 (c (n/2) lg(n/2)) + n = c n lgn - c n lg2 + n = c n lgn - c n + n c n lgn per c 1

14 Il metodo iterativo Sviluppare la ricorrenza ed esprimerla come somma di termini che dipendono solo da n e dalle condizioni al contorno. Per risolvere la ricorrenza si applicano le tecniche per limitare le sommatorie. Consideriamo di nuovo l equazione T(n) = 4T(n/2) + n T(n) = n + 4T(n/2) = n + 4 ( n/2 + 4 T(n/4)) = n + 2n (n/4 + 4 T(n/8) ) = n + 2n + 4n (n/8 + 4 T(n/16) ) = n + 2n lgn-1 n + 2 lgn T(1) = n ( lgn-1 ) + n Θ(1) = n (2 lgn - 1) + Θ(n) = n 2 - n + Θ(n) = Θ(n 2 )

15 Alberi di ricorsione Disegnamo l unfolding della ricorrenza T(n) = n + 4T(n/2) T(n) n T(n/2) T(n/2) T(n/2) T(n/2)

16 n n n/2 n/2 n/2 n/2 2n lgn n/4 n/4 n/4 n/4 n/4 n/4 n/4 n/4 n/4 n/4 n/4 n/4 n/4 n/4 n/4 n/4 4n 2 lgn Θ(1) Totale: lgn-1 n Σ 2 i + 2 lgn Θ(1) = n (n - 1) + n Θ(1) i=0 = Θ(n 2 )

17 Insertion-sort (A) {length[a] 1} 1 Insertion-sort for j 2 to length[a] (A) do 2 key A[j] {A[1..j-1] è ordinato} for j 2 to length[a] do key A[j] 3 {inserisci A[j] nella sequenza A[1..j-1] spostando a destra gli elementi > di A[j]} 4 i j-1 5 while {inserisci i > 0 A[j] and nella A[i] > sequenza key do A[1..j-1] 6 spostando A[i+1] a destra A[i] gli elementi > di A[j]} i j-1 7 i i-1 8 A[i+1] key while i > 0 and A[i] > key do A[i+1] A[i] i i-1 A[i+1] key {A[1..length[A]] è ordinato}

18 Al j-esimo passo: {A[1..j-1] e` ordinato} A j j length[a] 6 key A i j j

19 A j j length[a] A A j j i=2 key j {A[1..j] e` ordinato e l insieme degli elementi è ricostruito}

20 Insertion-sort (A) { A[1..j-1] è ordinato } for j 2 to n do key A[j] {inserisci A[j] nella sequenza A[1..j-1] spostando a destra gli elementi > di A[j]} i j-1 {A[1..j-1] è ordinato & A[i+1..j-1] > key} while i > 0 and A[i] > key do A[i+1] A[i] i i-1 {A[1..j-1] è ordinato & A[i+1..j-1] > key & A[i] key} A[i+1] key {A[1..n] è ordinato} O(n 2 )

21 Insertion-sort = O(n 2 ) n = length[a] Un algoritmo di ordinamento Divide et Impera Merge-Sort (A, p, q) if p < q then r (p + q)/2 Merge-Sort (A, p, r) Merge-Sort (A, r+1, q) Merge (A, p, r, q) n = q - p + 1 T(n) = T( n/2 ) + T( n/2 ) + Θ(n) per n 2

22 T(n) soddisfa T(n) = Θ(1) per n = 1 T(n) = 2T(n/2) + Θ(n) per n 2 n n lgn n/2 n/2 n n/4 n/4 n/4 n/4 n 2 lgn Θ(1) Totale: (lg n - 1) n + 2 lgn Θ(1) = Θ(n lgn)

23 T(n) = Q(n lgn) L algoritmo Merge-Sort è perciò asintoticamente migliore dell algoritmo Insertion-sort Si può inoltre dimostrare che Θ(n lgn) confronti sono necessari nel caso peggiore per ordinare n numeri per qualunque algoritmo basato sui confronti. Quindi l algoritmo Merge-Sort è (asintoticamente) ottimo.

24 Il metodo principale Teorema principale - versione semplificata Siano a 1, b > 1 e c 0 delle costanti. T(n) sia definita dalla seguente ricorrenza: T(n) = a T(n/b) + Θ(n c ) dove n/b rappresenta n/b oppure n/b. Allora T(n) è asintoticamente limitato nel modo seguente: se c < log b a allora T(n) = Θ(n log b a ) se c = log b a allora T(n) = Θ(n c lgn) se c > log b a allora T(n) = Θ(n c )

25 Esempi di uso del teorema principale Il tempo di calcolo per l algoritmo DI-Massimo-ricorsivo soddisfa la ricorrenza: T(n) = 2 T(n/2) + Θ(1) a = b = 2 c = 0 < 1 = log b a Caso 1 del teorema principale: T(n) = Θ(n log 2 2 ) = Θ(n)

26 Il tempo di calcolo per l algoritmo Merge-Sort soddisfa la ricorrenza: T(n) = 2 T(n/2) + Θ(n) a = b = 2 c = 1 = log b a Caso 2 del teorema principale: T(n) = Θ(n c lgn) = Θ(n lgn)

27 Ancora qualche esempio: 1. T(n) = 8 T(n/2) + n 2 a = 8 b = 2 c = 2 < 3 = log b a Caso 1 del teorema principale: T(n) = Θ(n log 2 8 ) = Θ(n 3 ) 2. T(n) = 7 T(n/2) + Θ(n 2 ) a = 7 b = 2 c = 2 < log b a Caso 1 del teorema principale: T(n) = Θ(n log 2 7 ) = O(n 3 )

28 Per le equazioni di ricorrenza: 1. T 1 (n) = 4 T(n/2) + n 2. T 2 (n) = 4 T(n/2) + n 2 3. T 3 (n) = 4 T(n/2) + n 3 Si applicano rispettivamente i casi 1, 2 e 3 del teorema principale: a = 4 b = 2 c = i log b a = 2 Si ha allora 1. T 1 (n) = Θ(n 2 ) 2. T 2 (n) = Θ(n 2 lgn) 3. T 3 (n) = Θ(n 3 )

29 Come possiamo leggere le complessità ottenute? Caso 1. T 1 (n) = 4 T(n/2) + n = Θ(n 2 ) si applica se il costo della divisione in sottoproblemi e della costruzione della soluzione a partire da quella dei sottoproblemi (n c ) è trascurabile rispetto al costo della soluzione dei sottoproblemi stessi (a T(n/b)). Caso 2. T 2 (n) = 4 T(n/2) + n 2 = Θ(n 2 lgn) si applica se il costo della divisione in sottoproblemi e della costruzione della soluzione a partire da quella dei sottoproblemi (n c ) è analogo al costo della soluzione dei sottoproblemi stessi (a T(n/b)). Caso 3. T 3 (n) = 4 T(n/2) + n 3 = Θ(n 3 ) si applica se il costo della divisione in sottoproblemi e della costruzione della soluzione a partire da quella dei sottoproblemi (n c ) è il fattore dominante