Algoritmi e Calcolo Parallelo 2012/2013 - Tecniche di Analisi

549 views

Published on

Slide del corso di Algoritmi e Calcolo Parallelo per il corso di laurea magistrale in Ingegneria Matematica 2012/2013 - Politecnico di Milano

Published in: Education
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
549
On SlideShare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
4
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide
  • 20070703
  • 20080214
  • 20080214
  • 20080307
  • n=1000n^2 = 1.000.000n^1.58 = 54954.1n log n log log n = 9965La versione n log n log log n è di Schönhage and Strassen 1971, Knuth 1981
  • Algoritmi e Calcolo Parallelo 2012/2013 - Tecniche di Analisi

    1. 1. Tecniche di Analisi Algoritmi e Calcolo Parallelo Prof. Pier Luca Lanzi
    2. 2. Riferimenti • • 2 Bertossi Alan A., Montresor Alberto. “Algoritmi e strutture di dati” (seconda edizione), CittàStudi 2010 Stanley B. Lippman, Barbara E. Moo, Josee Lajoie “C++ Primer”, 5th Edition Addison-Wesley Prof. Pier Luca Lanzi
    3. 3. Le maggiori difficoltà nell’analisi della complessità si incontra nell’… Analisi degli algoritmi ricorsivi Analisi del caso medio Analisi “ammortizzata” di una sequenza di operazioni Prof. Pier Luca Lanzi
    4. 4. Espandere fino a derivare una formula chiusa (merge sort) Usare relazioni di ricorrenza “comuni” (divide et impera/master theorem) “tentare” una soluzione Prof. Pier Luca Lanzi
    5. 5. Divide et Impera (Divide) Dividere il problema in sottoproblemi più semplici (Impera) Risolvere i sottoproblemi separatamente (ricorsivamente) Ricombinare i sottoproblemi nella soluzione Prof. Pier Luca Lanzi
    6. 6. Algoritmo di Merge Sort • 6 Divide: divide il vettore di lunghezza n in due sottovettori di n/2 elementi • Impera: Ordina ricorsivamente i due sottovettori • Ricombina: le soluzioni dei sottoproblemi in tempo lineare T(n) = 2T(n/2) + cn # sottoproblemi • Come calcoliamo T(n)? Sostituzione Master method   Prof. Pier Luca Lanzi grandezza dei sottoproblemi costo suddivisione e ricombinazione
    7. 7. Analisi di Algoritmi Ricorsivi: Master Method • • • • 7 T(n) = aT(n/b) + f(n) dove a≥1, b>1, ed f è asintoticamente positiva Caso 1: f (n) = O(nlogba – ε) per una costante ε > 0 Soluzione: T(n) = Θ(nlogba)  Caso 2: f (n) = Θ(nlogba lgkn) per una costante k≥0 Soluzione: T(n) = Q(nlogba lgk+1n)  Caso 3: f (n) = Ω(nlogba+ε) per una costante ε>0 f(n) soddisfa af (n/b)≤cf(n) per una costante c < 1 Soluzione: T(n) = Θ(f(n))   Prof. Pier Luca Lanzi
    8. 8. Ricorrenze Lineari con Partizione Bilanciata • Si applica a forme ricorsive del tipo, T(n) = d, se n=1 T(n) = aT(n/b) + cnβ dove a≥1, b>1 • Posto α = log a/log b T(n) = Θ(nα) se α>β T(n) = Θ(nαlogn) se α=β T(n) = Θ(nβ) se α<β 1. 2. 3. Prof. Pier Luca Lanzi 8
    9. 9. Esempio: Ricerca Binaria 9 • Divide: confronta l’elemento centrale • Impera: ricerca l’elemento in uno dei due sottovettori • Non c’è ricombinazione T(n) =1T(n/2) + c # sottoproblemi grandezza dei sottoproblemi • costo suddivisione e ricombinazione Per calcolare T(n), nlogba = nlog21 = n0 = 1, ovvero, il secondo caso con k=0, e quindi T(n) = Θ(lg n) Prof. Pier Luca Lanzi
    10. 10. Calcolo di an 10 • Calcolare an con n naturale • L’algoritmo tipico è Θ(n), possiamo fare di meglio? • Approccio Divide-et-Impera • se n è pari a (n–1)/2 × a (n–1)/2 × a an = a n/2 × a n/2 se n è dispari T(n) = T(n/2) + Θ(1) T(n) = Θ(lg n) Prof. Pier Luca Lanzi
    11. 11. Moltiplicazione fra Matrici Input: Output: A = [aij], B = [bij]. C = [cij] = A× B. c 11 c 12  c 1n c 21 c 22  c 2n   c n1 c n 2 11    c nn i, j = 1, 2,… , n. a11 a12  a1n a21 a22  a2n   an1 an 2 c ij n k 1 Prof. Pier Luca Lanzi    ann aik bkj b11 b12  b1n b21 b22  b2n   bn1 bn 2    bnn
    12. 12. Algoritmo Standard for i 1 to n do for j 1 to n do cij 0 for k 1 to n do cij cij + aik× bkj Complessità Θ(n3) Prof. Pier Luca Lanzi 12
    13. 13. Algoritmo Divide-et-Impera 13 matrice nxn = 2x2 matrice di (n/2)x(n/2) sottomatrici C C11 C12 C21 C22 = = = = = A11 B11 +A12 B21 A11 B12 +A12 B22 A21 B11 +A22 B21 A21 B21 +A21 B22 A × B 8 moltiplicazioni (n/2)´(n/2) 4 somme (n/2)´(n/2) Prof. Pier Luca Lanzi
    14. 14. Algoritmo Divide-et-Impera 14 T(n) =8T(n/2) + Θ(n2) # moltiplicazioni Su matrici n/2 nlogba = nlog28 = n3 Primo caso Nessun miglioramento! Prof. Pier Luca Lanzi Somme su matrici n/2xn/2 T(n) = Θ(n3)
    15. 15. Moltiplicazione fra Matrici: Metodo di Strassen • • • 15 Divide: suddivide A and B in sottomatrici di dimensione (n/2)x(n/2) utilizzati per creare i termini che devono essere moltiplicati usando + e– Impera: esegue 7 moltiplicazioni di sottomatrici (n/2)x(n/2) Ricombina: crea C usando somme e sottrazioni di sottomatrici (n/2)x(n/2) T(n) = 7 T(n/2) + nlogba = nlog27 » n2.81 (n2) Il migliore è (n2.37…) T(n) = Θ(nlg7) 2.81 sembra poco ma appare all’esponente! Prof. Pier Luca Lanzi
    16. 16. Domanda Sarebbe possibile parallelizzare la moltiplicazione fra matrici? Prof. Pier Luca Lanzi
    17. 17. Analisi Ammortizzata • • • • 17 Si considera il tempo richiesto per eseguire, nel caso pessimo, un'intera sequenza di operazioni In una sequenza di operazioni, ci sono operazioni costose e meno costose Se le operazioni più costose sono poco frequenti, allora il loro costo può essere ammortizzato dalle operazioni meno costose Importante differenza Analisi del caso medio: basata su probabilità, su singola operazione Analisi ammortizzata: deterministica, su operazioni multiple, caso pessimo   Prof. Pier Luca Lanzi
    18. 18. Tecniche per l’Analisi Ammortizzata • 18 Metodo dell'aggregazione Si calcola la complessità O(f(n)) per eseguire n operazioni in sequenza nel caso pessimo Il costo ammortizzato di una singola operazione è O(f(n)/n)   • Metodo degli accantonamenti (o del contabile) Alle operazioni vengono assegnati costi ammortizzati che possono essere maggiori/minori del loro costo effettivo Provare che la somma dei costi ammortizzati è un limite superiore al costo effettivo   • Metodo del potenziale (derivata dalla fisica) Lo stato del sistema viene descritto tramite differenze di potenziale  Prof. Pier Luca Lanzi
    19. 19. Esempio: Contatore Binario (1) • • • 19 Implementiamo un contatore binario di k bit con un array di bit Un numero binario x registrato in A ha il bit meno significativo in A[0] e il più significativo in A[k-1] per cui: Supponiamo che A venga usato per contare a partire da x=0 usando l’operazione di incremento Prof. Pier Luca Lanzi
    20. 20. Esempio: Contatore Binario (2) x 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 A[7] A[6] A[5] A[4] A[3] A[2] A[1] A[0] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0 1 3 4 7 8 10 11 15 16 18 19 22 23 25 26 31 Prof. Pier Luca Lanzi costo 20
    21. 21. Esempio: Contatore Binario (3) • 21 Analisi “grossolana” Una singola operazione di incremento richiede tempo O(k) nel caso pessimo Limite superiore O(nk) per una sequenza di n incrementi   • Analisi più accurata Osserviamo che il tempo necessario ad eseguire l’intera sequenza è proporzionale al numero di bit che vengono modificati Quanti bit vengono modificati?   Prof. Pier Luca Lanzi
    22. 22. Esempio: Contatore Binario (4) x 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 A[7] A[6] A[5] A[4] A[3] A[2] A[1] A[0] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0 1 3 4 7 8 10 11 15 16 18 19 22 23 25 26 31 Prof. Pier Luca Lanzi costo 22
    23. 23. Metodo dell’Aggregazione • 23 • Dalla simulazione si vede che: A[0] viene modificato ad ogni incremento del contatore, A[1] viene modificato ogni 2 incrementi, A[2] viene modificato ogni 4 incrementi.... In generale, A[i] viene modificato ogni 2i incrementi • Il costo aggregato è • Il costo ammortizzato: 2n/n = 2 = O(1)    Prof. Pier Luca Lanzi
    24. 24. Metodo degli Accantonamenti (o del contabile) • • 24 Si assegna un costo ammortizzato ai distinto* ad ognuna delle operazioni possibili che può essere diverso dal costo effettivo ci Le operazioni meno costose vengono caricate di un costo aggiuntivo detto credito costo ammortizzato = costo effettivo + credito prodotto • I crediti accumulati saranno usati per pagare le operazioni più costose costo ammortizzato = costo effettivo – credito consumato • (*) Nell'aggregazione, abbiamo calcolato costo ammortizzato costante Prof. Pier Luca Lanzi
    25. 25. Metodo degli Accantonamenti (o del contabile) • 25 Lo scopo è dimostrare che la somma dei costi ammortizzati ai è un limite superiore ai costi effettivi ci: dimostrare che il valore così ottenuto è “poco costoso” • Alcuni punti da ricordare La dimostrazione deve essere valida per tutte le sequenze di input (caso pessimo) Il credito è espresso dalla seguente formula e quindi è positivo   Prof. Pier Luca Lanzi
    26. 26. Contatore Binario con il Metodo degli Accantonamenti • • • 26 Il costo effettivo dell'operazione di incremento è d (dove d è il numero di bit che cambiano valore) Poniamo il costo ammortizzato dell'operazione di incremento pari a 2 1 per cambio del bit da 0 a 1 (costo effettivo) 1 per il futuro cambio dello stesso bit da 1 a 0   Ne segue che In ogni istante, il credito è pari al numero di bit 1 attualmente presenti Costo totale ammortizzato: O(n)   Prof. Pier Luca Lanzi
    27. 27. Metodo del Potenziale • • • 27 Una funzione potenziale Φ associa a ogni configurazione un numero reale Φi Φi è il valore della funzione potenziale dopo che è stata eseguita l’operazione i Il costo ammortizzato ai è calcolato come il costo effettivo ci più l’incremento di potenziale, ovvero ai = ci + Φi – Φi-1 • Il costo ammortizzato della sequenza di n operazioni diventa Σ ai = Σ ci + Φn – Φ0 • Nel caso del contatore Φi è il numero di bit a uno nella sequenza Prof. Pier Luca Lanzi
    28. 28. Contatore Binario con il Metodo dei Potenziali • 28 Scegliamo come funzione potenziale Φ(A) il numero bit 1 presenti nel contatore. operazione costo differenza di costo effettivo potenziale ammortizzato add • • 1+t -t+1 2 All'inizio, zero bit accesi, quindi Φ(A0) = 0 Alla fine, Φ(An) ≥ 0 e quindi la differenza di potenziale è non negativa, quindi il costo ammortizzato è un Prof. Pier Luca Lanzi
    29. 29. Problema 1 • 29 Si consideri la seguente modifica dell’algoritmo di mergesort che prende come input un array A e gli indici l and r e restituisce come output il vettore A in cui gli elementi da l a r sono ordinati. slowMergeSort(A, l, r) if (l < r) { int mid = (l + r)/2; slowMergeSort(A, l, mid) slowMergeSort(A, l, mid) //! Riapplica il sort slowMergeSort(A, mid + 1, r) merge(A, l, mid, r) } • Si calcoli la complessità dell’algoritmo slowMergeSort. Prof. Pier Luca Lanzi
    30. 30. Problema 2 • 30 Si consideri la relazione di ricorrenza T(n) =1 per n=1 T(n)<=2T(n/2)+n per n=2h, h>0 Si dimostri per induzione che T(n)<=cn per qualche costante c Prof. Pier Luca Lanzi
    31. 31. Problema 3 • 31 L’algoritmo di insertion sort può essere espresso coma una procedura ricorsiva in questo modo. Per ordinare un vettore A di n elementi (A[1..n]), prima ordiniamo il vettore corrispondente ai primi n-1 elementi (A[1..n-1]) e poi inseriamo l’elemento A[n] nel vettore ordinato A[1..n-1]. Scrivere una versione ricorsiva della funzione C++ per l’insertion sort vista a lezione. Scrivere l’equazione ricorrente per il tempo di ordinamento e calcolarne la complessità. Prof. Pier Luca Lanzi
    32. 32. Problema 4 • 32 Scrivere un programma C++ che legge da tastiera una sequenza di n numeri interi con valori da 0 a k (compreso) e poi può calcolare in un tempo O(1) quanti elementi sono compresi in un intervallo [a,b] specificato dall’utente. La complessità dell’algoritmo deve essere Θ(n+k). Prof. Pier Luca Lanzi
    33. 33. Problema 5 • 33 Data una sequenza di n elementi da ordinare, sappiamo che la sequenza consiste di n/k sottosequenze, ognuna delle quali contiene k elementi. Gli elementi di una sottosequenza sono più piccoli degli elementi nella sottosequenza successiva e più grandi che gli elementi della sequenza precedente. Quindi per ordinare tutta la sequenza di n elementi è sufficiente ordinare le n/k sottosequenze di k elementi. Mostrare che il numero di comparazioni necessarie per risolvere questo problema è limitato da Ω(n lg k). Prof. Pier Luca Lanzi
    34. 34. Problema 6 • • • 34 Moltiplicazione Numeri Complessi (a+bi)(c+di) = [ac – bd] + [ad + bc]i Input: a, b, c, d Output: ac-bd, ad+bc    Modello di calcolo Costo moltiplicazione: 1, costo addizione/sottrazione: 0.01  Domande Quanto costa l'algoritmo “banale” dettato dalla definizione? Si può fare di meglio? (Soluzione di Gauss)   Prof. Pier Luca Lanzi
    35. 35. Problema 7: Somma di Numeri Binari ************** *************** *************** 35 + **************** • • Algoritmo elementare della somma Richiede di esaminare tutti gli n bit Costo totale cn (c e’ il costo per sommare tre bit e generare riporto) Domanda: Esiste un metodo più efficiente?   Prof. Pier Luca Lanzi
    36. 36. Problema 8: Prodotto di Numeri Binari • 36 Algoritmo elementare n2 ******* ******* ******* ******* ******* ******* ******* ******* ******* Prof. Pier Luca Lanzi x
    37. 37. Prodotto di Numeri Binari • • • 37 Confronto fra i costi di esecuzione Somma: Tsum(n) = c1n Prodotto: Tprod(n) = c2n2 + c3n   Si potrebbe erroneamente concludere che il problema della moltiplicazione è inerentemente più costoso del problema dell'addizione (la nostra esperienza lo “conferma”) Per provare che il problema del prodotto è più costoso del problema della somma, dobbiamo provare che non esiste una soluzione in tempo lineare per il prodotto Prof. Pier Luca Lanzi
    38. 38. Prodotto di Numeri Binari: Dividi et Impera • • • • • • 38 Divide: dividi il problema in sottoproblemi di dimensioni inferiori Impera: risolvi i sottoproblemi in maniera ricorsiva Combina: unisci le soluzioni dei sottoproblemi in modo da ottenere la risposta del problema principale Moltiplicazione ricorsiva X = a2n/2 + b a b n/2 + d Y = c2 c d XY = ac2n + (ad+bc)2n/2 + bd Nota: Moltiplicare per 2t equivale a uno shift di t posizioni, in tempo lineare Sommare due vettori di bit anch’esso in tempo lineare Complessità      Prof. Pier Luca Lanzi
    39. 39. Prodotto di Numeri Binari: Gaussified-product (Karatsuba 1962) • • • 39 Definendo A1 = ac A3 = bd m = (a+b)(c+d)=ac+ad+bc+bd A2 = m−A1−A3=ad+bc Si ottiene, XY = A12n+A22n/2 + A3 Che ha una complessità pari a,      Tstandard(106) =1012 Tkaratsuba(106) = 3x109 Prof. Pier Luca Lanzi

    ×