Algoritmi e Strutture Dati. Capitolo 1 Un introduzione informale agli algoritmi

Transcript

1 Algoritmi e Strutture Dati Capitolo 1 Un introduzione informale agli algoritmi

2 Cos è un algoritmo? Procedimento chiaro e non ambiguo per risolvere correttamente un problema in tempo finito Esempio: algoritmo preparacaffè 2

3 Cos è un algoritmo? Noi siamo interessati ad algoritmi che risolvono problemi computazionali, cioè che producono, per un dato input, un output che rispetta la relazione definita dal problema considerato. 3

4 Perché studiare algoritmi? Gli algoritmi sono alla base dei programmi Livello di astrazione più alto: concentrarsi sull essenza dei problemi, tralasciando dettagli implementativi Livello di dettaglio sufficiente a derivare facilmente un programma da un algoritmo 4

5 Pseudocodice Per mantenere massimo grado di generalità, descriveremo algoritmi in pseudocodice: ricorda linguaggi di programmazione reali come C, C++ o Java può contenere alcune frasi in linguaggio naturale 5

6 Progetto ed analisi di algoritmi Vedremo come progettare ed analizzare (teoreticamente) algoritmi che: producano risultati corretti siano efficienti in termini di tempo di esecuzione ed occupazione di memoria 6

7 Perché analizzare algoritmi? Analisi teorica più affidabile di quella sperimentale: vale su tutte le possibili istanze di dati su cui l algoritmo opera Ci aiuta a scegliere tra diverse soluzioni allo stesso problema Permette di predire le prestazioni del software, prima ancora di scriverne le prime linee di codice 7

8 Visita guidata al progetto e analisi di algoritmi tramite esempio giocattolo : Calcolo dei numeri di Fibonacci (problema semplice ma con molte soluzioni) 8

9 L isola dei conigli Leonardo da Pisa (noto anche come Fibonacci) si interessò di molte cose, tra cui il seguente problema (dinamica delle popolazioni): Quanto velocemente si espande una popolazione di conigli sotto appropriate condizioni? In particolare, se partiamo da una coppia di conigli (in un isola deserta), quante coppie si avranno nell anno n? 9

10 Come modellare il problema? Come succede spesso in matematica (l analisi di algoritmi è matematica), iniziamo con una semplificazione del problema, che ne racchiuda i tratti essenziali Il modello può essere in seguito esteso, per renderlo più realistico 10

11 Modello e ipotesi sui conigli Una coppia di conigli genera due coniglietti ogni anno I conigli cominciano a riprodursi soltanto al secondo anno dopo la loro nascita I conigli sono immortali 11

12 Tasso di riproduzione dei conigli F n : numero di coppie di conigli presenti nell anno n F 1 = 1 (una sola coppia) F 2 = 1 (troppo giovani per procreare) F 3 = 2 (prima coppia di coniglietti) F 4 = 3 (seconda coppia di coniglietti) F 5 = 5 (prima coppia di nipotini) 12

13 L albero dei conigli La riproduzione dei conigli può essere descritta da: 13

14 Regola di espansione In generale in un certo anno ci saranno tutte le coppie dell anno precedente, più una nuova coppia di conigli per ogni coppia presente due anni prima Abbiamo quindi relazione di ricorrenza: F n = F n-1 + F n-2 se n 3 1 se n = 1,2 Problema algoritmico: come calcoliamo F n? 14

15 Un possibile approccio Possiamo usare direttamente una soluzione alla relazione di Fibonacci: dove: è la sezione aurea di un segmento 15

16 Algoritmo fibonacci1 16

17 Correttezza? Qual è l accuratezza di Φ e Φ ˆ necessaria per ottenere un risultato corretto? Ad esempio, se usiamo solo 3 cifre decimali: n fibonacci1(n) arrotondamento F n

18 Algoritmo fibonacci2 Poiché fibonacci1 non dà risultati corretti, come approccio alternativo potremmo utilizzare direttamente la definizione (ricorsiva) : algoritmo fibonacci2(intero n) intero if (n 2) then return 1 else return fibonacci2(n-1) + fibonacci2(n-2) Opera solo con numeri interi 18

19 Domande tipiche di questo corso Quanto tempo richiede fibonacci2? Come misuriamo il tempo? in secondi? (dipende da piattaforma) in istruzioni macchina? (dipende da compilatore ) Prima approssimazione: numero linee di codice mandate in esecuzione (indipendente da piattaforma e compilatore) 19

20 Tempo di esecuzione algoritmo fibonacci2(intero n) intero if (n 2) then return 1 else return fibonacci2(n-1) + fibonacci2(n-2) Se n 2, una sola linea di codice Se n = 3, 4 linee di codice: 2 per la chiamata fibonacci2(3) 1 per la chiamata fibonacci2(2) 1 per la chiamata fibonacci2(1) 20

21 Relazione di ricorrenza Per n 3 in ogni chiamata si eseguono 2 linee di codice, oltre a quelle eseguite nelle chiamate ricorsive: T(n) = 2 + T(n-1) + T(n-2) A parte il 2, è come per i conigli di Fibonacci! 21

22 Relazioni di ricorrenza In generale, tempo richiesto da algoritmi ricorsivi genera relazioni di ricorrenza Il tempo di ogni funzione è pari al tempo speso all interno della chiamata più il tempo speso nelle chiamate ricorsive Risolvendo la relazione di ricorrenza otteniamo l espressione del tempo 22

23 Alberi della ricorsione Utile per risolvere relazioni di ricorrenza Nodi corrispondenti a chiamate ricorsive Figli di un nodo corrispondenti alle sottochiamate 23

24 Alberi della ricorsione Per calcolare F(5) : 4 nodi interni, 2 linee di codice ciascuno 5 foglie, 1 linea di codice ciascuna Totale = 4 * * 1 = 13 linee di codice 24

25 Numero di linee di codice per F(n) Etichettiamo nodi dell albero con numero di linee di codice eseguite nella chiamata corrispondente: ogni nodo interno conta 2 ogni foglia conta 1 Per calcolare T(n) basta contare nell albero della ricorsione: numero di foglie numero di nodi interni 25

26 Calcolare numero di foglie Esercizio: dimostrate per induzione che: Numero di foglie dell albero della ricorsione di fibonacci2(n) è pari a F(n) 26

27 Calcolare numero di nodi interni Dimostreremo per induzione che Numero di nodi interni di un albero in cui ogni nodo ha zero oppure due figli è pari al numero di foglie

28 Induzione sul numero di foglie: Dimostrazione P (k) : se albero ha k foglie ha (k-1) nodi interni Base. P (1) : 1 foglia, 0 nodi interni. Banale. Passo induttivo. P (k) implica P (k+1) Per generare albero con k+1 foglie, attacchiamo due figli ad una (vecchia) foglia Numero di foglie: k = k + 1 Numero di nodi interni: (k -1) + 1 = k 28

29 Calcolare T(n) Numero di foglie dell albero della ricorsione di fibonacci2(n) è pari a F(n) Numero di nodi interni dell albero della ricorsione di fibonacci2(n) è pari a F(n) - 1 In totale numero di linee di codice eseguite è F(n) + 2 ( F(n) 1 ) = 3 F(n)

30 Possiamo fare di meglio? fibonacci2 è un algoritmo molto lento: T(n) F(n) Φ n Perché è lento? Continua a ricalcolare più volte la soluzione dello stesso sottoproblema! 30

31 Programmazione Dinamica Per evitare di risolvere più volte lo stesso sottoproblema, memorizziamo la soluzione dei vari sottoproblemi: algoritmo fibonacci3(intero n) intero sia Fib un array di n interi Fib[1] Fib[2] 1 for i = 3 to n do Fib[i] Fib[i-1] + Fib[i-2] return Fib[n] 31

32 Tempo richiesto da fibonacci3 algoritmo fibonacci3(intero n) intero sia Fib un array di n interi Fib[1] Fib[2] 1 for i = 3 to n do Fib[i] Fib[i-1] + Fib[i-2] return Fib[n] 3 linee di codice sono eseguite sempre Prima linea del ciclo eseguita (n-1) volte [ 1 per n=1] Seconda linea del ciclo eseguita (n-2) volte [ 0 per n=1] T(n) = 3 + n-1 + n-2 = 2n [ T(1) = 3+1 = 4 ] 32

33 fibonacci3 vs. fibonacci2 2n molto meglio di 3F n -2 L algoritmo fibonacci3 impiega tempo proporzionale a n piuttosto che esponenziale in n (fibonacci2) Tempo effettivo richiesto da implementazioni in C dei due algoritmi su piattaforme diverse: 33

34 Occupazione di memoria Tempo di esecuzione non è sola risorsa che ci interessa. Tempo di programmazione e lunghezza del codice (Ingegneria del Software) Anche quantità di memoria richiesta può essere cruciale. Se algoritmo lento, basta attendere più a lungo Ma se algoritmo richiede più spazio (RAM) di quello a disposizione, rischiamo di non ottenere mai la soluzione! 34

35 Algoritmo fibonacci4 fibonacci3 usa un array di dimensione n In realtà non ci serve mantenere tutti i valori di F n precedenti, ma solo gli ultimi due, riducendo lo spazio a poche variabili in tutto: algoritmo fibonacci4(intero n) intero a b 1 for i = 3 to n do c a+b a b b c return b 35

36 Notazione asintotica (1 / 4) Misurare T(n) come numero di linee di codice mandate in esecuzione è una misura molto approssimativa del tempo di esecuzione Se andiamo a capo più spesso, aumenteranno le linee di codice sorgente, ma certo non il tempo richiesto dall esecuzione del programma! 36

37 Notazione asintotica (2 / 4) Per lo stesso programma impaginato diversamente potremmo concludere ad esempio che T(n)=3n oppure T(n)=5n Vorremmo un modo per descrivere ordine di grandezza di T(n) ignorando dettagli inessenziali come costanti moltiplicative Useremo a questo scopo la notazione asintotica O 37

38 Notazione asintotica (3 / 4) Diremo che f(n) = O ( g(n) ) se f(n) c g(n) per qualche costante c, ed n abbastanza grande f(n) = Ο( g(n) ) cg(n) f(n) n 0 n 38

39 Notazione asintotica (4 / 4) Ad esempio, possiamo rimpiazzare: T(n)=3F con T(n)=O(F ) n n T(n)=2n e T(n)=4n con T(n)=O(n) T(n)= F con O(2 n ) n Notazione O semplifica la vita: Trascurare dettagli di basso livello Confrontare facilmente algoritmi Alg 2 e alg 4 sono O(n): meglio di O(2 n )! 39

40 Possiamo calcolare F n in tempo inferiore a O (n)? E semplice dimostrare (per induzione) la seguente proprietà di matrici: n = Potenze ricorsive F n+1 F n F n F n-1 Useremo questa proprietà per progettare un algoritmo più efficiente di fibonacci4 40

41 Algoritmo fibonacci5 Tempo di esecuzione è ancora O(n) Cosa abbiamo guadagnato? 41

42 Calcolo di potenze Possiamo calcolare la n-esima potenza elevando al quadrato la (n/2)-esima potenza Se n è dispari eseguiamo una ulteriore moltiplicazione Esempio: calcolare =9 3 4 =(9) 2 = =(81) 2 =

43 Algoritmo fibonacci6 43

44 Tutto il tempo è speso nella funzione potenzadimatrice All interno della funzione si spende tempo costante Si esegue una chiamata ricorsiva con input n/2 L equazione di ricorrenza è pertanto: Come risolverla? Tempo di esecuzione T(n) = O(1) + T(n/2) 44

45 T(n) c + T(n/2) c + c + T(n/4) = 2c + T(n/2 2 ) In generale: Per k = log 2 n si ottiene Metodo dell iterazione T(n) c k + T(n/2 k ) T(n) c log 2 n + T(1) = O(log 2 n ) fibonacci6 è quindi esponenzialmente più veloce di fibonacci3! 45

46 Riepilogo fibonacci2 fibonacci3 fibonacci4 fibonacci5 fibonacci6 Tempo di esecuzione O(2 n ) O(n) O(n) O(n) O(log n) Occupazione di memoria O(n) O(n) O(1) O(1) O(log n) 46

47 Cosa abbiamo imparato? 1. Progettare algoritmi efficienti cruciale 2. Come misurare tempo/spazio? metrica indipendente da piattaforme e tecnologie 3. In funzione di cosa esprimiamo risorse? dimensione dell input (per F n non è n ma log n) 4. Come confrontare algoritmi diversi? stima dell ordine di grandezza notazione O 5. Progetto/analisi richiedono strumenti matematici e.g., relazioni di ricorrenza, induzione, etc 47

48 Algoritmi e Strutture Dati Capitolo 2 Modelli di calcolo e metodologie di analisi

49 Notazione asintotica f (n) = risorsa (tempo di esecuzione / occupazione di memoria) richiesta da un algoritmo su input di dimensione n Notazione asintotica è astrazione utile per descrivere ordine di grandezza di f (n) ignorando dettagli non influenti, come ad esempio costanti moltiplicative e termini di ordine inferiore 2

50 Notazione asintotica O f (n) = O( g(n) ) se c > 0 e n 0 0 tali che f(n) c g(n) per ogni n n 0 f(n) = Ο( g(n) ) cg(n) f(n) n 0 n 3

51 f (n) = Ω( g(n) ) se c > 0 e n 0 0 tali che f(n) c g(n) per ogni n n 0 f(n) = Ω( g(n) ) Notazione asintotica Ω f(n) c g(n) n 0 n 4

52 f (n) = Θ( g(n) ) se c 1,c 2 > 0 e n 0 0 tali che c 1 g(n) f(n) c 2 g(n) per ogni n n 0 f(n) = Θ( g(n) ) Notazione asintotica Θ c 2 g(n) f(n) c 1 g(n) n 0 n 5

53 Notazione asintotica: esempi Consideriamo g(n) = 3n g(n) = O(n 2 ): basta scegliere c = 4 e n = 10 0 g(n) = Ω(n 2 ): basta scegliere c = 1 e n = 0 0 g(n) = Θ(n 2 ): infatti g(n) = Θ(f(n)) se e solo se g(n) = Ο(f(n)) e g(n) = Ω(f(n)) g(n) = O(n 3 ) ma g(n) Θ(n 3 ) 6

54 Metodi di analisi 7

55 Ricerca sequenziale Ricerca di elemento x in lista L non ordinata Quanti confronti per trovare x in L? Dipende da dove si trova x (all inizio, alla fine, non c è ) Vorremmo una risposta che non sia dipende 8

56 Caso peggiore, migliore e medio Misuriamo risorse di calcolo (tempo di esecuzione / occupazione di memoria) richieste da un algoritmo in funzione della dimensione n dell istanza d ingresso A parità di dimensione, istanze diverse potrebbero richiedere risorse diverse Distinguiamo ulteriormente tra analisi nel caso peggiore, migliore e medio 9

57 Caso peggiore Sia t (I) il tempo di esecuzione di un algoritmo su istanza I T (n) = max { t (I) } worst istanze I, I = n Intuitivamente, T (n) è tempo di worst esecuzione su istanze di ingresso che comportano più lavoro per l algoritmo Dà garanzie sulle prestazioni 10

58 Caso migliore T best (n) = min istanze I, I = n { t (I) } Intuitivamente, T (n) è il tempo di best esecuzione sulle istanze di ingresso che comportano meno lavoro per l algoritmo Non ci dà molta informazione 11

59 Caso medio P(I) probabilità di avere in ingresso istanza I T (n) = { P(I) t (I) } avg istanze I, I = n Intuitivamente, T (n) è tempo medio di avg esecuzione (ovvero su istanze di ingresso tipiche per il problema) Richiede conoscenza di distribuzione statistica dell input 12

60 Caso medio T (n) = { P(I) t (I) } avg istanze I, I = n Ipotesi su distribuzione statistica dell input? Possiamo avere algoritmi per cui nessun input richiede tempo medio (e.g., algoritmo richiede 1 o 100 passi) Più importante ma problematico nel definire input tipico 13

61 Ricerca sequenziale Ricerca di elemento x in lista L non ordinata T best (n) = 1 T worst (n) = n T avg (n) =??? (x è in prima posizione) (x L oppure è in ultima posizione) 14

62 Caso medio di ricerca sequenziale T (n) = { P(I) t (I) } avg istanze I, I = n Qual è la posizione tipica di x? Ipotesi : se x L, potrebbe stare ovunque P ( pos(x) = i ) = 1/n T (n) = { P( pos(x) = i ) i } = avg 1,..,n = { (1/n) i } = (1/n) { i } = 1,..,n 1,..,n = (n+1)/2 15

63 Ricerca sequenziale T best (n) = 1 T worst (n) = n T avg (n) = (n+1)/2 x è in prima posizione x L oppure è in ultima posizione ipotesi ragionevole: se x L, potrebbe stare ovunque T avg (n) = p (n+1)/2 + (1-p) n = n - p (n - 1) / 2 ipotesi di prima + P (x L) = p 16

64 Ricerca Binaria Ricerca di un elemento x in un array L ordinato Confronta x con elemento centrale di L e prosegue a sinistra o a destra in base ad esito del confronto 17

65 Analisi ricerca binaria T best (n) = 1 l elemento centrale è uguale a x T worst (n) =??? T avg (n) =??? 18

66 Analisi di algoritmi ricorsivi 19

67 Esempio L algoritmo di ricerca binaria può essere riscritto ricorsivamente come: Come analizzarlo? 20

68 Relazioni di ricorrenza Tempo di esecuzione può essere descritto tramite relazioni di ricorrenza: T(n) = c + T( n-1 / 2 ) se n > 1 1 se n = 1 simile a fibonacci6 Vari metodi per risolvere relazioni di ricorrenza: iterazione, sostituzione, teorema Master... 21

69 1. Metodo dell iterazione Idea: srotolare ricorsione, ottenendo sommatoria dipendente solo da dimensione n del problema iniziale Esempio: T(n) = c + T(n/2) T(n/2) = c + T(n/4)... T(n) = c + T(n/2) = 2c + T(n/4) = = ( j=1...i c ) + T(n/2 i ) = i c + T(n/2 i ) Per i = log 2 n: T(n) = c log 2 n + T(1) = O(log n) 22

70 Analisi ricerca binaria T best (n) = 1 T worst (n) = O( log n ) T avg (n) = log n -1+1/n l elemento centrale è uguale a x x L oppure viene trovato all ultimo confronto assumendo che le istanze siano equidistribuite 23

71 2. Metodo della sostituzione Idea: intuire soluzione, e usare induzione per verificare che la soluzione della relazione di ricorrenza sia effettivamente quella intuita Esempio: T(n) = n + T(n/2), con T(1)=1 Intuiamo soluzione T(n) c n per opportuna costante c Passo base. T(1) =1 c 1 per ogni c 1 Passo induttivo. T(n) = n + T(n/2) n + c (n/2) = (c/2+1) n T(n) c n sec/2+1 c ovvero per ogni c 2 24

72 3. Teorema Master Permette di analizzare algoritmi basati su tecnica del divide et impera: - dividi il problema (di dimensione n) in a sottoproblemi di dimensione n/b - risolvi ricorsivamente i sottoproblemi - ricombina le soluzioni Sia f(n) tempo per dividere e ricombinare istanze di dimensione n. La relazione di ricorrenza è data da: T(n) = a T(n/b) + f (n) se n > 1 1 se n = 1 25

73 Relazione di ricorrenza: T(n) = ammette soluzione: Teorema Master a T(n/b) + f (n) se n > 1 1 se n = 1 log b a log b a - ε 1. T(n) = Θ(n ) se f (n) = O(n ) per ε > 0 log 2. T(n) = Θ(n b a log log n) se f (n) = Θ(n b a ) log b a + ε 3. T(n) = Θ(f(n)) se f (n) = Ω(n ) per ε > 0 e a f (n/b) cf (n) per c < 1 e n sufficientemente grande 26

74 Teorema Master T(n) = a T(n/b) + f (n) se n > 1 1 se n = 1 Confronta le due funzioni n e f (n) : log b a log b a 1. T(n) = Θ(n ) se vince n log b a log 2. T(n) = Θ( f (n) log n ) se f (n) = Θ(n b a ) 3. T(n) = Θ( f (n) ) se vince f (n) log N.B. nei casi 1. e 3. T(n) = Θ( f (n) + n b a ) 27

75 1) T(n) = n + 2 T(n/2) log 2 2 Esempi a = 2, b = 2, f(n) = n = Θ(n ) T(n) = Θ(n log n) (Caso 2 del Teorema Master) 2) T(n) = c + 3 T(n/9) log ε a = 3, b = 9, f(n) = c = Ο(n ) T(n) = Θ( n) (Caso 1 del Teorema Master) 28

76 Esempi 3) T(n) = n + 3 T(n/9) log ε a = 3, b = 9, f(n) = n = Ω(n ) 3(n/9) c n per c = 1/3 (Caso 3 del Teorema Master) T(n) = Θ(n) 4) T(n) = n log 2 n + 2 T(n/2) Il Teorema Master non può essere applicato! log 2 2 log ε f (n) = n log 2 n = Ω ( n ) = Ω ( n ) f (n) = n log 2 n non è Ω ( n ) = Ω ( n ) ε 29

77 Dimostrazione Teorema Master T(n) = a T(n/b) + f (n) se n > 1 1 se n = 1 log 1. T(n) = Θ(n b a log ) se f (n) = O(n b a - ε ) per ε > 0 30

78 T(n) = a T(n/b) + f (n) = a 2 T(n/b 2 ) + a f (n/b) + f (n) = = a 3 T(n/b 3 ) + a 2 f (n/b 2 ) + a f (n/b) + f (n) = = Σ i=0,, log n a i f (n/b i ) b 31

79 f (n) = O(n log b a - ε ) T(n) = Σ i=0,, log n a i f (n/b i ) b a i f (n/b i ) = O( a i (n/b i log ) b a - ε ) = log b a - ε ε log b a i = O ( n ( a b / b ) ) = = O ( n log b a - ε (b ε) i ) T(n) = Σ = O ( n log b a - ε (b ε) i log ) = O ( n b a - ε Σ ε ( b ) i ) = O ( n log b a - ε ( n ε ) ) = O ( n log b a ) 32

80 Riepilogo Esprimiamo quantità di una certa risorsa di calcolo (tempo, spazio) usata da un algoritmo in funzione della dimensione n dell istanza di ingresso La notazione asintotica permette di esprimere quantità di risorsa usata dall algoritmo in modo sintetico, ignorando dettagli non influenti A parità di dimensione n dell istanza di ingresso, quantità di risorsa usata può essere diversa, da cui caso peggiore, caso medio Quantità di risorsa usata da algoritmi ricorsivi può essere espressa tramite relazioni di ricorrenza, risolvibili tramite metodi generali 33

81 Algoritmi e Strutture Dati Capitolo 3 Strutture dati elementari

82 Gestione di collezioni di oggetti Tipo di dato: Specifica delle operazioni di interesse su una collezione di oggetti (es. inserisci, cancella, cerca) Struttura dati: Organizzazione dei dati che permette di supportare le operazioni di un tipo di dato usando meno risorse di calcolo possibile 2

83 Il tipo di dato Dizionario 3

84 Il tipo di dato Pila 4

85 Il tipo di dato Coda 5

86 Tecniche di rappresentazione dei dati Rappresentazioni indicizzate: I dati sono contenuti in array Rappresentazioni collegate: I dati sono contenuti in record collegati fra loro mediante puntatori 6

87 Rappresentazioni indicizzate: Pro e contro Pro: accesso diretto ai dati mediante indici Contro: dimensione fissa (riallocazione array richiede tempo lineare) Rappresentazioni collegate: Pro: dimensione variabile (aggiunta e rimozione record in tempo costante) Contro: accesso sequenziale ai dati 7

88 Esempi di strutture collegate Lista semplice Lista doppiamente collegata Lista circolare doppiamente collegata 8

89 Alberi Organizzazione gerarchica dei dati Dati contenuti nei nodi, relazioni gerarchiche definite dagli archi che li collegano 9

90 Rappresentazioni collegate di alberi Rappresentazione con puntatori ai figli (nodi con numero limitato di figli) Rappresentazione con liste di puntatori ai figli (nodi con numero arbitrario di figli) 10

91 Rappresentazioni collegate di alberi Rappresentazione di tipo primo figliofratello successivo (nodi con numero arbitrario di figli) 11

92 Visite di alberi Algoritmi che consentono l accesso sistematico ai nodi e agli archi di un albero Gli algoritmi di visita si distinguono in base al particolare ordine di accesso ai nodi 12

93 Algoritmo di visita generica visitagenerica visita il nodo r e tutti i suoi discendenti in un albero Richiede tempo O(n) per visitare un albero con n nodi a partire dalla radice 13

94 Algoritmo di visita in profondità L algoritmo di visita in profondità (DFS) parte da r e procede visitando nodi di figlio in figlio fino a raggiungere una foglia. Retrocede poi al primo antenato che ha ancora figli non visitati (se esiste) e ripete il procedimento a partire da uno di quei figli. 14

95 Algoritmo di visita in profondità Versione iterativa (per alberi binari): 15

96 Algoritmo di visita in profondità Versione ricorsiva (per alberi binari): 16

97 Algoritmo di visita in ampiezza L algoritmo di visita in ampiezza (BFS) parte da r e procede visitando nodi per livelli successivi. Un nodo sul livello i può essere visitato solo se tutti i nodi sul livello i-1 sono stati visitati. 17

98 Algoritmo di visita in ampiezza Versione iterativa (per alberi binari): 18

99 Riepilogo Nozione di tipo di dato come specifica delle operazioni su una collezione di oggetti Rappresentazioni indicizzate e collegate di collezioni di dati: pro e contro Organizzazione gerarchica dei dati mediante alberi Rappresentazioni collegate classiche di alberi Algoritmi di esplorazione sistematica dei nodi di un albero (algoritmi di visita) 19

100 Algoritmi e Strutture Dati Capitolo 4 Ordinamento

101 Ordinamento Dato un insieme S di n oggetti presi da un dominio totalmente ordinato, ordinare S Esempi: ordinare alfabeticamente lista di nomi, o insieme di numeri, o insieme di compiti d esame in base a cognome studente Subroutine di molti problemi E possibile effettuare ricerche in array ordinati in tempo O(log n) 2

102 Algoritmi e tempi tipici Numerosi algoritmi Tre tempi tipici: O(n 2 ), O(n log n), O(n) n n log 2 n ~ 33 ~ 665 ~ 10 4 ~ ~ n

103 Algoritmi di ordinamento 4

104 SelectionSort Approccio incrementale. Estende ordinamento da k a (k+1) elementi, scegliendo minimo tra (n-k) elementi non ancora ordinati e mettendolo in posizione (k+1)

105 SelectionSort: analisi k - esima estrazione di minimo costa tempo O(n-k) In totale, il tempo di esecuzione è: n-1 k=1 O(n-k) = ( n-1 i=1 i O ) = O(n2 ) [ cambiamento di variabile (i = n k) e serie aritmetica ] 6

106 InsertionSort Approccio incrementale. Estende ordinamento da k a (k+1) elementi, posizionando elemento (k+1)-esimo nella posizione corretta rispetto ai primi k elementi

107 InsertionSort: analisi Inserimento del k-esimo elemento nella posizione corretta rispetto ai primi k richiede tempo O(k) nel caso peggiore In totale, il tempo di esecuzione è : [ serie aritmetica ] ( n-1 k=1 k O ) = O(n2 ) 8

108 BubbleSort Esegue una serie di scansioni dell array In ogni scansione confronta coppie di elementi adiacenti, scambiandoli se non sono nell ordine corretto Dopo una scansione in cui non viene effettuato nessuno scambio l array è ordinato Dopo la k-esima scansione, i k elementi più grandi sono correttamente ordinati ed occupano le k posizioni più a destra correttezza e tempo di esecuzione O(n 2 ) 9

109 Esempio di esecuzione (1) (2) (3) (4) (5)

110 O( n 2 ) è quanto di peggio si possa fare: tutti i confronti possibili! Possiamo fare di meglio? 11

111 1. QuickSort 2. MergeSort 3. HeapSort 12

112 Usa la tecnica del divide et impera: QuickSort 1 Divide: scegli un elemento x della sequenza (pivot) e partiziona la sequenza in elementi x ed elementi > x 2 Risolvi i due sottoproblemi ricorsivamente 3 Impera: restituisci la concatenazione delle due sottosequenze ordinate 13

113 Partizione in loco Scorri l array in parallelo da sinistra verso destra e da destra verso sinistra da sinistra verso destra, ci si ferma su un elemento maggiore del pivot da destra verso sinistra, ci si ferma su un elemento minore del pivot Scambia gli elementi e riprendi la scansione Tempo di esecuzione: O(n) 14

114 Partizione in loco: un esempio

115 Analisi nel caso peggiore Nel caso peggiore, il pivot scelto ad ogni passo è il minimo o il massimo degli elementi nell array Il numero di confronti nel caso peggiore è : C(n) = C(n-1) + O(n) Risolvendo per iterazione si ottiene C(n) = O(n 2 ) 16

116 input dopo partition output Esempio di esecuzione L albero delle chiamate ricorsive può essere sbilanciato

117 Randomizzazione Possiamo evitare il caso peggiore scegliendo come pivot un elemento a caso Poiché ogni elemento ha la stessa probabilità, pari a 1/n, di essere scelto come pivot, il numero di confronti nel caso atteso è: C(n)= n-1 a=0 n-1 1 n-1+c(a)+c(n-a-1) = n-1+ 2 n C(a) n a=0 dove a e (n-a-1) sono le dimensioni dei sottoproblemi risolti ricorsivamente 18

118 Analisi nel caso medio La relazione di ricorrenza ha soluzione C(n) 2 n log n n-1 C(n)= n-1+ a=0 2 n C(a) Dimostrazione per sostituzione Assumiamo per ipotesi induttiva che C(i) 2 i log i n-1 C(n) n-1+ i=0 n 2 2 i log i n-1+ 4 n n 2 x log x dx Integrando per parti si dimostra che C(n) 2 n log n 19

119 MergeSort Usiamo la tecnica del divide et impera: 1 Divide: dividi l array a metà 2 Risolvi il sottoproblema ricorsivamente 3 Impera: fondi le due sottosequenze ordinate Rispetto a QuickSort, divide semplice ed impera complicato 20

120 Fusione (Merge) Due array ordinati A e B possono essere fusi rapidamente: estrai ripetutamente il minimo di A e B e copialo nell array di output, finché A oppure B non diventa vuoto copia gli elementi dell array non vuoto alla fine dell array di output Tempo: O(n), dove n è il numero totale di elementi 21

121 Mergesort: esempio di esecuzione input output Input ed output delle chiamate ricorsive

122 Tempo di esecuzione Numero di confronti del MergeSort descritto da relazione di ricorrenza: C(n) = 2 C(n/2) + O(n) Da Teorema Master si ottiene la soluzione C(n) = O(n log n) 23

123 HeapSort Stesso approccio incrementale del SelectionSort Usa però struttura dati più efficiente per estrarre massimo ad ogni iterazione Struttura dati heap associata ad insieme S : albero binario radicato con le seguenti proprietà: 1) completo fino al penultimo livello 2) elementi di S memorizzati nei nodi dell albero 3) chiave(padre(v)) chiave(v) per ogni nodo v 24

124 Struttura dati heap Rappresentazione ad albero e con vettore posizionale vettore posizionale sin(i) = 2i des(i) = 2i

125 Heap con struttura rafforzata Le foglie nell ultimo livello sono compattate a sinistra vettore posizionale Il vettore posizionale ha esattamente dimensione n

126 Proprietà salienti degli heap 1) Il massimo è contenuto nella radice 2) L albero ha altezza O(log n) 1) Gli heap con struttura rafforzata possono essere rappresentati in un array di dimensione n 27

127 La procedura fixheap Se tutti i nodi di H tranne v soddisfano la proprietà di ordinamento a heap, possiamo ripristinarla come segue: fixheap(nodo v, heap H) if (v è una foglia) then return else sia u il figlio di v con chiave massima if ( chiave(v) < chiave(u) ) then scambia chiave(v) e chiave(u) fixheap(u,h) Tempo di esecuzione: O(log n) 28

128 Estrazione del massimo Copia nella radice la chiave contenuta nella la foglia più a destra dell ultimo livello Rimuovi la foglia Ripristina la proprietà di ordinamento a heap richiamando fixheap sulla radice Tempo di esecuzione: O(log n) 29

129 Costruzione dell heap Algoritmo ricorsivo basato su divide et impera heapify(heap H) if (H è vuoto) then return else heapify(sottoalbero sinistro di H) heapify(sottoalbero destro di H) fixheap(radice di H,H) Tempo di esecuzione: T(n) = 2 T(n/2) + O(log n) T(n) = O(n) dal Teorema Master 30

130 HeapSort Costruisci un heap tramite heapify Estrai ripetutamente il massimo per (n-1) volte ad ogni estrazione memorizza il massimo nella posizione dell array che si è appena liberata O(n) O(n log n) ordina in loco in tempo O(n log n) 31

131 Esempio di esecuzione (1) (2) (3) (4) (5) (6) 32

132 Possiamo fare meglio di O(n log n)? 33

133 Lower bound Dimostrazione (matematica) che non possiamo andare più veloci di una certa quantità Più precisamente, ogni algoritmo all interno di un certo modello di calcolo deve avere tempo di esecuzione almeno pari a quella quantità Non significa necessariamente che non è possibile fare di meglio (basta cambiare il modello ) 34

134 Delimitazione inferiore: quantità di risorsa necessaria per risolvere un determinato problema Dimostrare che Ω(n log n) è lower bound al numero di confronti richiesti per ordinare n oggetti. Come? Lower bound Dobbiamo dimostrare che tutti gli algoritmi richiedono Ω(n log n) confronti! 35

135 Modello basato su confronti In questo modello, per ordinare è possibile usare solo confronti tra oggetti Primitive quali operazioni aritmetiche (somme o prodotti), logiche (and e or), o altro (shift) sono proibite Sufficientemente generale per catturare le proprietà degli algoritmi più noti 36

136 Consideriamo un qualsiasi algoritmo A, che ordina solo mediante confronti Non abbiamo assolutamente idea di come funziona A! Ciò nonostante, dimostreremo che A deve eseguire almeno Ω(n log n) confronti Dato che l unica ipotesi su A è che ordini mediante confronti, il lower bound sarà valido per tutti gli algoritmi basati su confronti! 37 Come dimostrare lower bound

137 Alberi di decisione Strumenti per rappresentare algoritmi di ordinamento Descrivono sequenza di confronti che un algoritmo esegue su istanze di lunghezza n 38

138 Alberi di decisione = algoritmi basati su confronti! Ogni algoritmo basato su confronti può essere rappresentato da un albero di decisione: confronti scelti dall algoritmo possono dipendere solo dagli esiti dei confronti precedenti! Un albero di decisione può essere letto come algoritmo basato su confronti: per ogni input, il cammino nell albero descrive confronti da effettuare e permutazione che produce soluzione 39

139 Proprietà alberi di decisione Per una particolare istanza, i confronti eseguiti da A su quella istanza sono rappresentati da un cammino radice - foglia Il numero di confronti nel caso peggiore è pari all altezza dell albero di decisione Un albero di decisione per l ordinamento di n elementi contiene almeno (n!) foglie (una per ogni possibile permutazione degli n oggetti) 40

140 Un albero binario con k foglie tale che ogni nodo interno ha esattamente due figli ha altezza almeno log 2 k Dimostrazione per induzione su k: Passo base: 0 log 2 1 h(k) 1 + h(k/2) poiché uno dei due sottoalberi ha almeno metà delle foglie h(k/2) log 2 (k/2) per ipotesi induttiva h(k) 1 + log 2 (k/2) = log 2 k Lower bound 41

141 Il lower bound Ω (n log n) L albero di decisione ha almeno n! foglie La sua altezza è almeno log 2 (n!) Formula di Stirling: n! (2πn) 1/2 (n/e) n Quindi: log 2 (n!) = Ω (n log n) 42

142 Ordinamenti lineari (per dati con proprietà particolari) 43

143 Sappiamo che gli n elementi da ordinare sono tutti distinti e nell intervallo [1,n] In quanto tempo possiamo ordinarli? O(1) Contraddice il lower bound? No. Perché? 44

144 IntegerSort: fase 1 Meno banale: ordinare n interi con valori in [1,k] Mantieni array Y di k contatori tale che Y[x] = numero di occorrenze di x X Y X Y (a) Calcolo di Y 45

145 IntegerSort: fase 2 Scandisci Y da sinistra verso destra. Se Y[x] = k, scrivi in X il valore x per k volte X Y X Y (b) Ricostruzione di X 46

146 IntegerSort: analisi O(k) per inizializzare contatori a 0 O(n) per calcolare valori dei contatori O(n + k) per ricostruire sequenza ordinata O(n + k) Tempo lineare se k = O(n) 47

147 BucketSort Per ordinare n record con chiavi intere in [1,k] Basta mantenere un array di liste, anziché di contatori, ed operare come per IntegerSort La lista Y[x] conterrà gli elementi con chiave uguale a x Concatenare poi le liste Tempo O(n + k) come per IntegerSort 48

148 Stabilità Un algoritmo è stabile se preserva ordine iniziale tra elementi uguali (stessa chiave) QuickSort è stabile se la partizione lo rende stabile MergeSort è stabile se divisione lo rende stabile (pari e dispari non lo rende stabile) HeapSort non è stabile BucketSort può essere reso stabile appendendo gli elementi di X in coda alla opportuna lista Y[i] 49

149 RadixSort Cosa fare se k > n, ad esempio k = Θ(n c )? Rappresentiamo gli elementi in base b, ed eseguiamo una serie di BucketSort Procediamo dalla cifra meno significativa a quella più significativa Per b=

150 Correttezza Se x e y hanno una diversa t-esima cifra, la t-esima passata di BucketSort li ordina Se x e y hanno la stessa t-esima cifra, la proprietà di stabilità del BucketSort li mantiene ordinati correttamente Dopo la t-esima passata di BucketSort, i numeri sono correttamente ordinati rispetto alle t cifre meno significative 51

151 Tempo di esecuzione O(log b k) passate di bucketsort Ciascuna passata richiede tempo O(n + b) O( (n + b) log b k) Se b = Θ(n), si ha O(n log n k) = O n log k log n Tempo lineare se k = O(n c ), c costante 52

152 Nuove tecniche algoritmiche: Incrementale (SelectionSort, InsertionSort) Divide et impera (MergeSort, QuickSort) Plug in di strutture dati efficienti (HeapSort) Randomizzazione (QuickSort) Riepilogo Alberi di decisione per dimostrare lower bound Sfruttare proprietà dei dati in ingresso (fuori dal modello) per progettare algoritmi più efficienti: algoritmi lineari 53

153 Algoritmi e Strutture Dati Capitolo 5 Selezione e statistiche di ordine

154 Problemi di statistiche d ordine Estrarre da grandi quantità di dati un piccolo insieme di indicatori che ne rappresentino caratteristiche statisticamente salienti Esempi: minimo, massimo, media, moda (valore più frequente), mediano. Selezione (k,n): Dati insieme di n elementi ed intero k [1,n], trovare elemento che occuperebbe la k-esima posizione se l insieme fosse ordinato Mediano: selezione per k = n/2 2

155 Selezione: approcci naïf Ordina gli elementi, poi restituisci quello in posizione k : O(n log n) Costruisci un heap, ed estrai il minimo per k volte: O(n + k log n) O(n) se k = O(n/log n) ma non risolve problema del mediano in tempo lineare! 3

156 Calcolo randomizzato del mediano (con numero atteso di confronti lineare ) 4

157 Usare QuickSort? 1. Divide: scegli pivot x e partiziona in elementi x ed elementi > x 2. Risolvi due sottoproblemi (QuickSort) 3. Impera: concatena sottosequenze ordinate 4. Restituisci k-esimo elemento nella sequenza Numero atteso di confronti O(n log n) Possiamo fare di meglio? 5

158 Usare QuickSort? 1. Divide: scegli pivot x e partiziona in elementi x ed elementi > x 2. Risolvi UN SOTTOPROBLEMA (QuickSort) 3. Impera: concatena sottosequenze 4. Restituisci k-esimo elemento nella sequenza Numero atteso di confronti: ancora O(n log n) Possiamo fare di meglio? 6

159 QuickSelect 1. Divide: scegli pivot x e partiziona in elementi x ed elementi > x 2. Risolvi un solo sottoproblema (RICORSIVAMENTE) 7

160 QuickSelect 8

161 Analisi nel caso peggiore Nel caso peggiore, pivot scelto ad ogni passo è minimo o massimo degli elementi nell array Numero di confronti nel caso peggiore è: C(n) = C(n-1) + O(n) Risolvendo per iterazione si ottiene C(n) = O(n 2 ) 9

162 QuickSelect Randomizzato Come per QuickSort, possiamo evitare caso peggiore scegliendo pivot a caso Ad ogni passo eliminiamo almeno A + min{ A, A } elementi 10

163 Analisi di QuickSelect Numero atteso di confronti: Relazione di ricorrenza dipenderà da k e da n Difficile da risolvere Ci aspettiamo caso più difficile per k = n/2 11

164 Intuizione Maggior numero di confronti in QuickSelect si ha per k = n/2, ovvero nel caso del mediano A 1 A 3 < x > x k n/2 A 1 A 3 < x > x k n/2 A 1 A 3 < x > x (a) (b) (c) Per k < n/2 ci sono maggiori possibilità di ricorrere sul più piccolo dei due insiemi A 1 e A 3 k n/2 12

165 Analisi di QuickSelect Randomizzato Ad ogni passo eliminiamo almeno A 2 + min{ A 1, A 3 } elementi Ogni elemento ha stessa probabilità di essere scelto come pivot: probabilità di ricorrere su array di dimensione i [n/2,n-1] è 2/n Numero di confronti nel caso atteso è quindi: C(n) = n-1+ n-1 i=n/2 2 n C(i) 13

166 Analisi di QuickSelect Randomizzato Dimostriamo per sostituzione che C(n) A n C(n) = n-1+ n-1+ n-1 i=n/2 n-1+ 2 ( n A n-1 2 C(i) n-1+ n n-1 i=n/2 i=n/2 2 n A i n-1 i=1 n/2-1 2 A i n-1+ 2 A( i - n n i ) i=1 n2 2 - n2 8 - n 4 ) = ( 1 + 3A 4 ) n -1- A 2 ( 1 + 3A 4 ) n C(n) A n se ( 1 + 3A 4 ) A ovvero A 4 14

167 Numero atteso di confronti Relazione di ricorrenza del QuickSelect ha soluzione C(n) 4 n Il numero atteso di confronti di QuickSelect è lineare 15

168 Algoritmo usato in pratica Per convergere rapidamente, scegli il pivot il più vicino possibile al k-esimo (dal lato giusto) Come? Scegli un campione opportuno (m elementi) Scegli il pivot come il j-esimo degli m elementi: j = k m n + - δ 16

169 Calcolo deterministico del mediano (con un numero lineare di confronti nel caso peggiore) 17

170 Algoritmo deterministico Derandomizzare l algoritmo randomizzato Segui l idea dell algoritmo usato in pratica Scegli un campione deterministico (non casuale) Scegli il pivot come il mediano del campione 18

171 Algoritmo deterministico: dettagli 1. Scegli n/5 quintuple 2. Per ogni quintupla calcola il mediano 3. Il campione è definito dai mediani delle quintuple 4. Calcola (ricorsivamente) il pivot come mediano dei mediani 5. Prosegui ricorsivamente (come per l algoritmo randomizzato) 19

172 Select Calcolo deterministico del pivot tramite una chiamata ricorsiva (riga 6) 20

173 Mediano dei mediani Pivot M è mediano dei mediani m i dei n/5 gruppi di 5 elementi Mediano di 5 elementi può essere calcolato con al più 7 confronti l implementazione della riga 5 richiede (7/5) n confronti (ordinando i 5 elementi) La riga 6 è una chiamata ricorsiva su n/5 elementi La partizione (righe 7-10) richiede n-1 confronti 21

174 Seconda chiamata ricorsiva La chiamata ricorsiva nella riga 11 (riga 12) viene effettuata su un insieme contenente al più 7n/10 +3 elementi n/5 mediani dei gruppi di n/10 22

175 Algoritmo deterministico: analisi 1. Scegli n/5 quintuple 2. Per ogni quintupla calcola mediano 3. Campione definito da mediani delle quintuple 4. Calcola (ricorsivamente) il pivot come mediano dei mediani 5. Partiziona intorno al pivot 6. Prosegui ricorsivamente (come per l algoritmo randomizzato) (7/5) n T( n/5 ) n-1 T( (7/10) n ) 23

176 Analisi La seguente relazione di ricorrenza descrive il numero di confronti eseguiti da select nel caso peggiore: T(n) (12/5) n + T( n/5 ) + T( (7/10) n ) La relazione di ricorrenza ha soluzione T(n) = O(n) Facile dimostrare per sostituzione che T(n) c n per c 24 24

177 Riepilogo Abbiamo risolto il problema del calcolo del mediano studiandone una generalizzazione, ovvero il calcolo del k-esimo elemento per k [1,n] A volte problema più generale più semplice da risolvere del problema originario (dà più facilmente luogo a sottoproblemi ricorsivi) Il problema della selezione può essere risolto in tempo lineare, sia con algoritmi randomizzati che con algoritmi deterministici L algoritmo randomizzato, sebbena richieda tempo O (n 2 ) nel caso peggiore, è più efficiente in pratica 25

178 Algoritmi e Strutture Dati Capitolo 6 Alberi di ricerca

179 Dizionari Gli alberi di ricerca sono usati per realizzare in modo efficiente il tipo di dato dizionario 2

180 Alberi binari di ricerca (BST = binary search tree) 3

181 Definizione Albero binario che soddisfa le seguenti proprietà ogni nodo v contiene un elemento elem(v) cui è associata una chiave chiave(v) presa da un dominio totalmente ordinato le chiavi nel sottoalbero sinistro di v sono tutte chiave(v) le chiavi nel sottoalbero destro di v sono tutte chiave(v) 4

182 Esempi Albero binario di ricerca Albero binario NON di ricerca 5

183 search(chiave k) -> elem Traccia cammino nell albero partendo da radice: su ogni nodo, usa proprietà di ricerca per decidere se proseguire nel sottoalbero sinistro o destro 6

184 insert(elem e, chiave k) 1. Crea un nuovo nodo u con elem = e e chiave = k 3. Cerca la chiave k nell albero, identificando così il nodo v che diventerà padre di u 4. Appendi u come figlio sinistro/destro di v in modo che sia mantenuta la proprietà di ricerca 7

185 Ricerca del massimo 8

186 Ricerca del predecessore 9

187 delete(elem e) Sia u il nodo contenente l elemento e da cancellare: 1) u è una foglia: rimuovila 2) u ha un solo figlio: 10

188 delete(elem e) 3) u ha due figli: sostituiscilo con il predecessore (v) e rimuovi fisicamente il predecessore (che ha un solo figlio) 11

189 Costo delle operazioni Tutte le operazioni hanno costo O(h) dove h è l altezza dell albero O(n) nel caso peggiore (alberi molto sbilanciati e profondi) 12

190 Alberi AVL (Adel son-vel skii e Landis) 13

191 Definizioni Fattore di bilanciamento di un nodo v = altezza sottoalbero sinistro di v - altezza sottoalbero destro di v Un albero si dice bilanciato in altezza se ogni nodo v ha fattore di bilanciamento 1 Alberi AVL = alberi binari di ricerca bilanciati in altezza 14

192 Altezza di alberi AVL Si può dimostrare che un albero AVL con n nodi ha altezza O(log n) Idea della dimostrazione: tra tutti gli AVL di altezza h, consideriamo quelli con minimo numero di nodi n h (alberi di Fibonacci) Si ha: n h = 1 + n h-1 + n h-2 = F h

193 Implementazione delle operazioni L operazione search procede come in un BST Ma inserimenti e cancellazioni potrebbero sbilanciare l albero Manteniamo il bilanciamento tramite opportune rotazioni 16

194 Rotazione di base Mantiene la proprietà di ricerca Richiede tempo O(1) 17

195 Ribilanciamento tramite rotazioni Le rotazioni sono effettuate su nodi sbilanciati Sia v un nodo con fattore di bilanciamento 2 Esiste un sottoalbero T di v che lo sbilancia A seconda della posizione di T si hanno 4 casi: I quattro casi sono simmetrici (a coppie) 18

196 Rotazione SS Applicare una rotazione semplice verso destra su v L altezza dell albero coinvolto nella rotazione passa da h+3 a h+2 19

197 Rotazione SD Applicare due rotazioni semplici: una sul figlio del nodo critico, l altra sul nodo critico L altezza dell albero coinvolto nella rotazione passa da h+3 a h+2 20

198 insert(elem e, chiave k) 1. Crea un nuovo nodo u con elem=e e chiave=k 2. Inserisci u come in un BST 3. Ricalcola i fattori di bilanciamento dei nodi nel cammino dalla radice a u: sia v il più profondo nodo con fattore di bilanciamento pari a ±2 (nodo critico) 4. Esegui una rotazione opportuna su v N.B.: una sola rotazione è sempre sufficiente, poiché l altezza dell albero coinvolto diminuisce di 1 21

199 delete(elem e) 1. Cancella il nodo come in un BST 2. Ricalcola i fattori di bilanciamento dei nodi nel cammino dalla radice al padre del nodo eliminato fisicamente (che potrebbe essere il predecessore del nodo contenente e) 3. Ripercorrendo il cammino dal basso verso l alto, esegui l opportuna rotazione semplice o doppia sui nodi sbilanciati N.B.: potrebbero essere necessarie O(log n) rotazioni 22

200 Cancellazione con rotazioni a cascata 23

201 Classe AlberoAVL 24

202 Costo delle operazioni Tutte le operazioni hanno costo O(log n) poché l altezza dell albero è O(log n) e ciascuna rotazione richiede solo tempo costante 25

203 Riepilogo Mantenere bilanciamento sembra cruciale per ottenere buone prestazioni Esistono vari approcci per mantenere bilanciamento: Tramite rotazioni (alberi AVL ) Tramite fusioni o separazioni di nodi (alberi 2-3, B-alberi ) In tutti questi casi si ottengono tempi di esecuzione logaritmici nel caso peggiore E anche possibile non mantenere in modo esplicito alcuna condizione di bilanciamento, ed ottenere tempi logaritmici ammortizzati su una intera sequenza di operazioni (alberi auto-aggiustanti) 26

204 Algoritmi e Strutture Dati Capitolo 7 Tavole hash

205 Implementazioni Dizionario Tempo richiesto dall operazione più costosa: - Liste - Alberi di ricerca non bilanciati - Alberi di ricerca bilanciati - Tavole hash O(n) O(n) O(log n) O(1) 2

206 Tavole ad accesso diretto Sono dizionari basati sulla proprietà di accesso diretto alle celle di un array Idea: dizionario memorizzato in array v di m celle a ciascun elemento è associata una chiave intera nell intervallo [0,m-1] elemento con chiave k contenuto in v[k] al più n m elementi nel dizionario 3

207 Implementazione 4

208 Fattore di carico Misuriamo il grado di riempimento di una tavola usando il fattore di carico α = n m Esempio: tavola con nomi di studenti indicizzati da numeri di matricola a 6 cifre n=100 m=10 6 α = 0,0001 = 0,01% Grande spreco di memoria! 5

209 Pregi: Pregi e difetti Tutte le operazioni richiedono tempo O(1) Difetti: Le chiavi devono essere necessariamente interi in [0, m-1] Lo spazio utilizzato è proporzionale ad m, non al numero n di elementi: può esserci grande spreco di memoria! 6

210 Tavole hash Per ovviare agli inconvenienti delle tavole ad accesso diretto ne consideriamo un estensione: le tavole hash Idea: Chiavi prese da un universo totalmente ordinato U (possono non essere numeri) Funzione hash: h: U [0, m-1] (funzione che trasforma chiavi in indici) Elemento con chiave k in posizione v[h(k)] 7

211 Le tavole hash possono soffrire del fenomeno delle collisioni. Collisioni Si ha una collisione quando si deve inserire nella tavola hash un elemento con chiave u, e nella tavola esiste già un elemento con chiave v tale che h(u)=h(v): il nuovo elemento andrebbe a sovrascrivere il vecchio! 8

212 Funzioni hash perfette Un modo per evitare il fenomeno delle collisioni è usare funzioni hash perfette. Una funzione hash si dice perfetta se è iniettiva, cioè per ogni u,v U: u v h(u) h(v) Deve essere U m 9

214 Esempio Tavola hash con nomi di studenti aventi come chiavi numeri di matricola nell insieme U=[234717, ] Funzione hash perfetta: h(k) = k n=100 m=1000 α = 0,1 = 10% L assunzione U m necessaria per avere una funzione hash perfetta è raramente conveniente (o possibile) 11

215 Esempio Tavola hash con elementi aventi come chiavi lettere dell alfabeto U={A,B,C, } Funzione hash non perfetta (ma buona in pratica per m primo): h(k) = ascii(k) mod m Ad esempio, per m=11: h( C ) = h( N ) se volessimo inserire sia C and N nel dizionario avremmo una collisione! 12

216 Uniformità delle funzioni hash Per ridurre la probabilità di collisioni, una buona funzione hash dovrebbe essere in grado di distribuire in modo uniforme le chiavi nello spazio degli indici della tavola Questo si ha ad esempio se la funzione hash gode della proprietà di uniformità semplice 13

217 Uniformità semplice Sia P(k) la probabilità che la chiave k sia presente nel dizionario e sia: la probabilità che la cella i sia occupata. Una funzione hash h gode dell uniformità semplice se: 14

218 Esempio Se U è l insieme dei numeri reali in [0,1] e ogni chiave ha la stessa probabilità di essere scelta, allora si può dimostrare che la funzione hash: soddisfa la proprietà di uniformità semplice 15

219 Risoluzione delle collisioni Nel caso in cui non si possano evitare le collisioni, dobbiamo trovare un modo per risolverle. Due metodi classici sono i seguenti: 1. Liste di collisione. Gli elementi sono contenuti in liste esterne alla tabella: v[i] punta alla lista degli elementi tali che h(k)=i 2. Indirizzamento aperto. Tutti gli elementi sono contenuti nella tabella: se una cella è occupata, se ne cerca un altra libera 16

220 Liste di collisione Esempio di tabella hash basata su liste di collisione contenente le lettere della parola: PRECIPITEVOLIS SIMEVOLMENTE 17

222 Indirizzamento aperto Supponiamo di voler inserire un elemento con chiave k e la sua posizione naturale h(k) sia già occupata. L indirizzamento aperto consiste nell occupare un altra cella, anche se potrebbe spettare di diritto a un altra chiave. Cerchiamo la cella vuota (se c è) scandendo le celle secondo una sequenza di indici: c(k,0), c(k,1), c(k,2), c(k,m-1) 19

224 Metodi di scansione: scansione lineare Scansione lineare: c(k,i) = ( h(k) + i ) mod m per 0 i < m 21

225 Esempio Inserimenti in tavola hash basata su indirizzamento aperto con scansione lineare delle lettere della parola: 4,8 celle scandite in media per inserimento 22 PRECIPITEVOLIS SIMEVOLMENTE

226 Metodi di scansione: hashing doppio La scansione lineare provoca effetti di agglomerazione, cioè lunghi gruppi di celle consecutive occupate che rallentano la scansione L hashing doppio riduce il problema: c(k,i) = h (k) + i h (k) mod m 1 2 per 0 i < m, h1 e h funzioni hash 2 23

227 Esempio Inserimenti in tavola hash basata su indirizzamento aperto con hashing doppio delle lettere della parola: PRECIPITEVOLIS SIMEVOLMENTE 3,1 celle scandite in media per inserimento 24

228 Analisi del costo di scansione Tempo richiesto in media da un operazione di ricerca di una chiave, assumendo che le chiavi siano prese con probabilità uniforme da U: dove α=n/m (fattore di carico) 25

229 Cancellazione elementi con indir. aperto 26

230 La proprietà di accesso diretto alle celle di un array consente di realizzare dizionari con operazioni in tempo O (1) indicizzando gli elementi usando le loro stesse chiavi (purché siano intere) L array può essere molto grande se lo spazio delle chiavi è grande Per ridurre questo problema si possono usare funzioni hash che trasformano chiavi (anche non numeriche) in indici Usando funzioni hash possono aversi collisioni Riepilogo Tecniche classiche per risolvere le collisioni sono liste di collisione e indirizzamento aperto 27

231 Algoritmi e Strutture Dati Capitolo 8 Code con priorità

232 Tipo di dato CodaPriorità (1/2) 2

233 Tipo di dato CodaPriorità (2/2) 3

234 Tre implementazioni d-heap: generalizzazione degli heap binari visti per l ordinamento heap binomiali heap di Fibonacci 4

235 d-heap 5

236 Definizione Un d-heap è un albero radicato d-ario con le seguenti proprietà: 2. Struttura: è completo almeno fino al penultimo livello 3. Contenuto informativo: ogni nodo v contiene un elemento elem(v) ed una chiave chiave(v) presa da un dominio totalmente ordinato 4. Ordinamento a heap: per ogni nodo v (diverso dalla radice) chiave(v) chiave(parent(v)) 6

237 Esempio Heap d-ario con 18 nodi e d = 3 7

238 Proprietà 1. Un d-heap con n nodi ha altezza O(log d n) 3. La radice contiene l elemento con chiave minima (per via della proprietà di ordinamento a heap) 5. Può essere rappresentato implicitamente tramite vettore posizionale grazie alla proprietà di struttura 8

239 Procedure ausiliarie Utili per ripristinare la proprietà di ordinamento a heap su un nodo v che non la soddisfi T(n) = O(log d n) T(n) = O(d log d n) 9

240 findmin T(n) = O(1) 10

241 insert(elem e, chiave k) T(n) = O(log d n) ( muovialto ) 11

242 delete(elem e) e deletemin T(n) = O(d log d n) ( muovibasso ) Può essere usata anche per implementare cancellazione del minimo 12

243 decreasekey(elem e, chiave d) T(n) = O(log d n) ( muovialto ) 13

244 increasekey(elem e, chiave d) T(n) = O(d log d n) ( muovibasso ) 14

245 Heap binomiali 15

246 Alberi binomiali Albero binomiale B h (definito ricorsivamente) : 2. B 0 consiste di un unico nodo 3. Per i 0, B i+1 ottenuto fondendo due alberi binomiali B i con radice di uno figlia della radice dell altro 16

247 Proprietà strutturali 17

248 Definizione di heap binomiale Un heap binomiale è una foresta di alberi binomiali con le seguenti proprietà: 2. Struttura: ogni albero B i nella foresta è un albero binomiale 3. Unicità: per ogni i, esiste al più un B i nella foresta 4. Contenuto informativo: ogni nodo v contiene un elemento elem(v) ed una chiave chiave(v) presa da un dominio totalmente ordinato 5. Ordinamento a heap: per ogni nodo v (diverso da una delle radici) chiave(v) chiave(parent(v)) 18

249 Proprietà In un heap binomiale con n nodi, vi sono al più log 2 n alberi binomiali, ciascuno con grado ed altezza O(log n) 19

250 Procedura ausiliaria Utile per ripristinare la proprietà di unicità in un heap binomiale T(n) è proporzionale al numero di alberi binomiali in input 20

251 Realizzazione (1/3) 21

253 Realizzazione (3/3) Tutte le operazioni richiedono tempo T(n) = O(log n) Durante l esecuzione della procedura ristruttura esistono infatti al più tre B i, per ogni i 0 23

254 Analisi Ammortizzata 24

255 Metodologie di analisi di algoritmi Finora abbiamo visto tre tipi di analisi: Analisi nel caso peggiore Analisi nel caso medio Analisi nel caso atteso (algoritmi randomizzati) Ne vedremo un altro: Analisi ammortizzata 25

256 Analisi ammortizzata Strutture dati con garanzia assoluta sui loro tempi di esecuzione: analisi di caso peggiore per operazione (esempio: analisi di heap in heapsort) Analisi ammortizzata: non ci interessa tanto caratterizzare tempo richiesto nel caso peggiore da un operazione sulla struttura dati quanto caratterizzare tempo totale richiesto dalle operazioni sulla struttura dati ovvero tempo medio di un operazione, dove la media è sulla sequenza di operazioni 26

257 Analisi ammortizzata Supponiamo di avere una sequenza di σ operazioni su una particolare struttura dati La sequenza richiede tempo totale O(σ t) per essere eseguita Diremo che il tempo ammortizzato per ogni operazione della sequenza è O(t) Media sulla sequenza: O(σ t) / σ = O(t) Nota: una singola operazione potrebbe richiedere più di O(t) nel caso peggiore! 27

258 Analisi ammortizzata Sequenza di σ operazioni richiede tempo O(σ t) Tempo ammortizzato: O(σ t) / σ = O(t) OK per molte applicazioni Abbiamo bisogno di utilizzare strutture dati su sequenze di operazioni Analizzare prestazioni su sequenze di prestazioni 28

259 Esempio 1 Pila con le seguenti due operazioni push(x): push elemento x sulla pila multipop(k): esegui k pop sulla pila (se la pila ha almeno k elementi) Analisi nel caso peggiore: push(x): O(1) multipop(k): O( min{ k, P } ) = O(n) dove P è la dimensione della pila 29

260 Esempio 1 Analisi nel caso peggiore: push(x): O(1) multipop(k): O( min { k, P } ) = O(n) dove P è la dimensione della pila Quanto tempo richiederà una sequenza di σ operazioni? No! O(σ n)? 30

261 Analisi ammortizzata dell Esempio 1 Intuizione: Prima di togliere un elemento x con una multipop dobbiamo averlo inserito con una push (x) Ogni sequenza di σ push e multipop richiede in totale tempo O(σ ) Tempo ammortizzato per operazione: O(σ ) / σ = Ο(1) Vedremo un analisi più formale di questo 31

262 Metodologie di analisi ammortizzata Tre tipologie di analisi diverse: Metodo cumulativo: Sequenza di σ operazioni richiede tempo O(σ t) Tempo ammortizzato: O(σ t) / σ = O(t) Metodo del banchiere: Per eseguire un passo dobbiamo pagare 1 EUR Allocare EUR in modo da pagare per tutti i passi Metodo del potenziale: Analogia con analisi potenziale (Fisica) 32

263 Metodo del Banchiere per Esempio 1 Quando esegui push(x) sborsa 2 EUR: 1 EUR per pagare lavoro richiesto da push(x) 1 EUR conservato nell elemento x Quando esegui multipop(k) sborsa 0 EUR: lavoro richiesto da multipop(k) pagato dagli EUR conservati negli elementi! 1. Per ogni operazione sborsi al più O(1) EUR 2. Tutti gli EUR sborsati sufficienti a pagare per lavoro richiesto dalle operazioni 33

264 Metodo del Potenziale 34 Definisci potenziale Φ per struttura dati D Φ(D) misura potenzialità di D ad eseguire lavoro (configurazione attuale) Durante operazione i-esima, struttura dati passa da configurazione D i a configurazione D i+1 Passa da potenziale Φ(D i ) a potenziale Φ(D i+1 ) Tenere in conto variazione di potenziale Φ = Φ(D i+1 ) - Φ(D i ) Operazione può essere molto costosa ma mette struttura dati in grado di eseguire più efficientemente operazioni future (costo operazione compensato da Φ )

265 Metodo del Potenziale Tipicamente potenziale Φ soddisfa le: Φ(D 0 ) = 0 e Φ(D i ) 0 per ogni i Definiamo tempo ammortizzato a i dell operazione i- esima: a i = t i + Φ(D i+1 ) - Φ(D i ) dove t i è il tempo (attuale) operazione i-esima Sommando su sequenza di operazioni Σ i a i = Σ i t i + Σ ( i Φ(D i+1 ) - Φ(D i ) ) Σ i a i = Σ i t i + ( Φ(D n ) - Φ(D 0 ) ) Σ i a i Σ i t i 35

266 Metodo del Potenziale per Esempio 1 Definiamo potenziale Φ della pila P: Φ(P) = P Nota che: Φ(P 0 ) = 0 e Φ(P i ) 0 per ogni i Tempo ammortizzato a i di operazione i-esima: a i = t i + Φ(D i+1 ) - Φ(D i ) Costo ammortizzato di push(x) : a i = t i + Φ(D i+1 ) - Φ(D i ) = = 2 Costo ammortizzato di multipop(k) : a i = t i + Φ(D i+1 ) - Φ(D i ) = k + ( -k) = 0 36

267 Heap di Fibonacci 37

268 Heap di Fibonacci Heap binomiale rilassato: si ottiene da un heap binomiale rilassando la proprietà di unicità dei B i ed utilizzando un atteggimento più pigro durante l operazione insert (perché ristrutturare subito la foresta quando potremmo farlo dopo?) Heap di Fibonacci: si ottiene da un heap binomiale rilassato rilassando la proprietà di struttura dei B i che non sono più necessariamente alberi binomiali Analisi sofisticata: i tempi di esecuzione sono ammortizzati su sequenze di operazioni 38

269 Conclusioni: tabella riassuntiva L analisi di DHeap e HeapBinomiale è nel caso peggiore, mentre quella per HeapBinomialeRilassato e HeapFibonacci è ammortizzata 39

270 Algoritmi e Strutture Dati Capitolo 9 Union-find

271 Il problema Union-find Mantenere una collezione di insiemi disgiunti di elementi distinti (interi in 1 n) durante una sequenza delle seguenti operazioni: union(a,b) = unisce gli insiemi A e B in un unico insieme, di nome A, e distrugge i vecchi insiemi A e B find(x) = restituisce il nome dell insieme contenente l elemento x makeset(x) = crea il nuovo insieme {x} 2

272 Esempio n = 6 L elemento in grassetto dà il nome all insieme 3

273 Approcci elementari 4

274 Algoritmi di tipo QuickFind Usano alberi di altezza uno per rappresentare gli insiemi disgiunti: Radice = nome dell insieme Foglie = elementi find e makeset richiedono solo tempo O(1), ma union è molto inefficiente: O(n) nel caso peggiore 5

275 Esempio 6

278 Algoritmi di tipo QuickUnion Usano alberi di altezza anche maggiore di uno per rappresentare gli insiemi disgiunti: Radice = elemento rappresentativo dell insieme Nodi e Foglie = altri elementi union e makeset richiedono solo tempo O(1), ma find è molto inefficiente: O(n) nel caso peggiore 9

279 Esempio 10

282 Altezza lineare Sequenza di union che costruisce un albero di altezza lineare 13

283 Euristiche di bilanciamento nell operazione union 14

284 Bilanciamento in algoritmi QuickFind Nell unione degli insiemi A e B, modifichiamo il padre dei nodi nell insieme di cardinalità minore 15

287 Realizzazione (3/3) T am = tempo per operazione ammortizzato su una intera sequenza 18

288 Conseguenza del bilanciamento Ogni volta che una foglia di un albero QuickFind bilanciato acquista un nuovo padre a causa di un operazione union, dopo la union tale foglia farà parte di un insieme che è grande almeno il doppio dell insieme di cui faceva parte precedentemente 19

289 Analisi ammortizzata (1/2) Se eseguiamo m find, n makeset (e quindi al più n-1 union), il tempo richiesto dall intera sequenza di operazioni è O(m + n log n) Idea della dimostrazione 1. Facile vedere che find e makeset richiedono tempo O(n+m) 2. Per analizzare union, quando creiamo un nodo gli assegnamo log n crediti: in totale, O(n log n) crediti 20

290 Analisi ammortizzata (2/2) 3. Quando eseguiamo una union, paghiamo il tempo speso su ogni nodo il cui padre cambia con uno dei crediti assegnati al nodo 4. Un nodo può cambiare al più log n padri, poiché ogni volta che cambia padre la cardinalità dell insieme cui appartiene raddoppia 5. I crediti assegnati al nodo sono quindi sufficienti per pagare tutti i cambiamenti di padre 21

291 Bilanciamento in algoritmi QuickUnion Union by rank: nell unione degli insiemi A e B, rendiamo la radice dell albero più basso figlia della radice dell albero più alto rank(x) = altezza dell albero di cui x è radice 22

295 Conseguenza del bilanciamento Un albero QuickUnion bilanciato in altezza con radice x ha almeno 2 rank(x) nodi Dimostrazione: induzione sul numero di operazioni Se rank(a) > rank(b) durante una union: Se rank(a) < rank(b): simmetrico Se rank(a) = rank(b): 26

296 Analisi (nel caso peggiore) Per la proprietà precedente, l altezza di un albero QuickUnion bilanciato è limitata superiormente da log 2 n, con n = numero di makeset L operazione find richiede nel caso peggiore tempo O(log n) 27

297 Bilanciamento in algoritmi QuickUnion Union by size: nell unione degli insiemi A e B, rendiamo la radice dell albero con meno nodi figlia della radice dell albero con più nodi size(x) = numero nodi nell albero di cui x è radice Stesse prestazioni di union by rank 28

298 Riepilogo sul bilanciamento 29

299 Euristiche di compressione nell operazione find 30

300 Path compression, splitting e halving Siano u 0, u 1,, u t-1 i nodi incontrati nel cammino esaminato da find (x), con x = u 0 Path compression: rendi il nodo u i figlio della radice u t-1, per ogni i t-3 Path splitting: rendi il nodo u i figlio del nonno u i+2, per ogni i t-3 Path halving: rendi il nodo u 2i figlio del nonno u 2i+2, per ogni i (t-1)/2-1 31

301 albero prima di find(x) Esempi Path compression Path halving Path splitting 32

302 Union-find con bilanciamento e compressione 33

303 Combinazioni delle euristiche Combinando le euristiche di bilanciamento e compressione si ha un totale di sei algoritmi: ( union by rank o union by size ) x ( path splitting, path compression, o path halving ) Tutti gli algoritmi hanno le stesse prestazioni, asintoticamente superiori a quanto visto finora 34

304 Terminologia La funzione log * cresce molto lentamente 35

305 Analisi Combinando le euristiche di bilanciamento e compressione, una qualunque sequenza di n operazioni makeset, m operazioni find ed al più (n-1) operazioni union può essere implementata in tempo totale O( (n+m) log*n) ( Non è la migliore analisi possibile ) 36

306 Conclusioni Strutture dati efficienti per il problema unionfind Partendo da strutture dati semplici con prestazioni non soddisfacenti, le abbiamo migliorate tramite l uso di opportune euristiche di bilanciamento ed euristiche di compressione di cammini Nonostante le euristiche siano estremamente semplici, l analisi si è rivelata molto sofisticata 37

307 Algoritmi e Strutture Dati Capitolo 10 Tecniche algoritmiche

308 1. Divide et impera 2. Programmazione dinamica 3. Greedy 2

309 Divide et impera Tecnica top-down: 3. Dividi il problema in due o più sottoproblemi 4. Risolvi (ricorsivamente) i sottoproblemi 5. Ricombina soluzioni dei sottoproblemi per ottenere la soluzione del problema originario Esempi: ricerca binaria, mergesort, quicksort, 3

310 Moltiplicare (o sommare) due numeri non è sempre eseguibile in tempo costante: se i numeri occupano più di una parola di memoria, anche le operazioni elementari potrebbero richiedere tempo superiore a O(1) Moltiplicare due numeri a n cifre, con l algoritmo classico (scuola elementare), richiede O(n 2 ). Possiamo fare di meglio? Moltiplicazione di interi di lunghezza arbitraria 4

311 Rappresentazione decimale di interi a n cifre Dividiamo X e Y a metà: X 1 (Y 1 ) = n/2 cifre più significative di X (Y) X 0 (Y 0 ) = n/2 cifre meno significative di X (Y) 5

312 Divisione del problema 6

313 Osservazioni Moltiplicare un numero per 10 k = shift a sinistra delle cifre del numero di k posizioni Somma di due numeri di k cifre: tempo O(k) La moltiplicazione di due numeri a n cifre si riduce quindi a: quattro moltiplicazioni di numeri a n/2 cifre un numero costante di operazioni implementabili in tempo O(k) 7

314 Equazione di ricorrenza La soluzione è Θ(n 2 ) dal Teorema Master Cosa abbiamo guadagnato? 8

315 Ridurre il numero di moltiplicazioni 9

316 Analisi Eseguiamo tre moltiplicazioni e un numero costante di somme e shift La soluzione è Θ(n Master log 2 3 ) = Θ(n 1.59 ) dal Teorema 10

317 Programmazione Dinamica 11

318 Programmazione Dinamica Per evitare di risolvere più volte lo stesso sottoproblema, memorizziamo la soluzione dei vari sottoproblemi: algoritmo fibonacci3(intero n) intero sia Fib un array di n interi Fib[1] Fib[2] 1 for i = 3 to n do Fib[i] Fib[i-1] + Fib[i-2] return Fib[n] 12

319 Programmazione dinamica Tecnica bottom-up: 3. Identifica sottoproblemi del problema originario, procedendo logicamente dai problemi più piccoli verso quelli più grandi 4. Utilizza una tabella per memorizzare soluzioni dei sottoproblemi incontrati: quando incontri lo stesso sottoproblema, leggi la soluzione nella tabella 5. Si usa quando i sottoproblemi non sono indipendenti, (lo stesso sottoproblema può apparire più volte) Esempio: numeri di Fibonacci 13

320 Distanza tra stringhe Siano X e Y due stringhe di lunghezza m ed n: Vogliamo calcolare la distanza tra X e Y, ovvero il minimo numero di operazioni elementari che consentono di trasformare X in Y 14

321 Trasformare RISOTTO in PRESTO: 15

322 Approccio Indichiamo con δ(x,y) la distanza tra X e Y Indichiamo con X i il prefisso di X fino all i-esimo carattere, per 0 i m (X 0 è la stringa vuota): Risolveremo il problema di calcolare δ(x,y) calcolando δ(x i,y j ) per ogni i, j tali che 0 i m e 0 j n Manterremo le informazioni in una tabella D di dimensione m n 16

323 Inizializzazione della tabella Alcuni sottoproblemi sono banali: δ(x 0,Y j ) = j partendo dalla stringa vuota X 0, basta inserire uno ad uno i primi j caratteri di Y j δ(x i,y 0 ) = i partendo da X i, basta rimuovere uno ad uno gli i caratteri di X i per ottenere Y 0 Queste soluzioni sono memorizzate rispettivamente nella prima riga e nella prima colonna della tabella D 17

324 Avanzamento nella tabella (1/3) Se x i = y j, il minimo costo per trasformare X i in Y j è uguale al minimo costo per trasformare X i-1 in Y i-1 D [ i, j ] = D [ i-1, j-1 ] Se x i y j, distinguiamo in base all ultima operazione usata per trasformare X i in Y j in una sequenza ottima di operazioni 18

325 Avanzamento nella tabella (2/3) il minimo costo per trasformare X i in Y j è uguale al minimo costo per trasformare X i in Y j-1 più 1 per inserire il carattere y j D [ i, j ] = 1 + D [ i, j-1 ] il minimo costo per trasformare X i in Y j è uguale al minimo costo per trasformare X i-1 in Y j più 1 per la cancellazione del carattere x i D [ i, j ] = 1 + D [ i-1, j ] 19

326 In conclusione: Avanzamento nella tabella (3/3) il minimo costo per trasformare X i in Y j è uguale al minimo costo per trasformare X i-1 in Y j-1 più 1 per sostituire il carattere x i per y j D [ i, j ] = 1 + D [ i-1, j-1 ] 20

327 Pseudocodice Tempo di esecuzione ed occupazione di memoria: O(m n) 21

328 Esempio La tabella D costruita dall algoritmo. In grassetto sono indicate due sequenze di operazioni che permettono di ottenere la distanza tra le stringhe 22

329 Tecnica golosa (o greedy) 23

330 Problemi di ottimizzazione (1/2) Usata in problemi di ottimizzazione (e.g., trovare cammino più corto per andare da Napoli a Torino) Ad ogni passo, algoritmo effettua la scelta localmente più promettente 1. Insieme di candidati (e.g., città) 2. Insieme dei candidati già esaminati 3. Funzione ammissibile(): verifica se un insieme di candidati rappresenta una soluzione, anche non ottima (un insieme di città è un cammino da Napoli a Torino?) 24

331 Problemi di ottimizzazione (2/2) 1. Funzione ottimo(): verifica se un insieme di candidati rappresenta una soluzione ottima (un insieme di città è il più breve cammino da Napoli a Torino?) 2. Funzione seleziona(): indica quale dei candidati non ancora esaminati è al momento il più promettente 3. Funzione obiettivo da minimizzare o massimizzare (e.g., lunghezza del cammino da Napoli a Torino) 25

332 Tecnica golosa Perché goloso? Sceglie sempre il candidato più promettente! 26

333 Un problema di sequenziamento Un server (e.g., una CPU, o un impiegato dell ufficio postale) deve servire n clienti Il servizio richiesto dall i-esimo cliente richiede t i secondi Chiamiamo T(i) il tempo di attesa del cliente i Vogliamo minimizzare il tempo di attesa medio, i.e.: e quindi 27

334 Esempio Sei possibili ordinamenti: Qual è il migliore? 28

335 Un algoritmo goloso Il seguente algoritmo genera l ordine di servizio in maniera incrementale secondo una strategia greedy. Supponiamo di aver deciso di sequenziare i clienti i 1, i 2, i m. Se decidiamo di servire il cliente j, il tempo totale di servizio diventa: Quindi al generico passo l algoritmo serve la richiesta più corta tra quelle rimanenti Tempo di esecuzione: O(n log n), per ordinare le richieste 29

336 Riepilogo Tecniche algoritmiche: Divide et impera: altre applicazioni nella ricerca binaria, mergesort, quicksort, moltiplicazione di matrici Programmazione dinamica: altre applicazioni nel calcolo dei numeri di Fibonacci, associatività del prodotto tra matrici, cammini minimi tra tutte le coppie di nodi (algoritmo di Floyd e Warshall) Tecnica greedy: altre applicazioni nel distributore automatico di resto, nel calcolo del minimo albero ricoprente (algoritmi di Prim, Kruskal, Boruvka) e dei cammini minimi (algoritmo di Dijkstra) 30

337 Algoritmi e Strutture Dati Capitolo 11 Grafi e visite di grafi

338 Definizione Un grafo G = (V,E) consiste in: - un insieme V di vertici (o nodi) - un insieme E di coppie di vertici, detti archi: ogni arco connette due vertici Esempio 1: V = {persone che vivono in Italia}, E = {coppie di persone che si sono strette la mano} Esempio 2: V = {persone che vivono in Italia}, E = { (x,y) tale che x ha inviato una mail a y} 2

339 Terminologia (1/2) Esempio 1: relazione simmetrica Esempio 2: relazione non simmetrica grafo non orientato grafo orientato n = numero di vertici m = numero di archi L ed I sono adiacenti (L,I) è incidente a L I ha grado 4: δ(i) = 4 δ(v) = 2m v V 3

340 Terminologia (2/2) < L, I, E, C, B, A > è un cammino nel grafo di lunghezza 5 Non è il più corto cammino tra L ed A La lunghezza del più corto cammino tra due vertici si dice distanza: L ed A hanno distanza 4 4

341 Strutture dati per rappresentare grafi 5

342 Grafi non orientati 6

343 Grafi orientati 7

344 Prestazioni della lista di archi 8

345 Prestazioni delle liste di adiacenza 9

346 Prestazioni della matrice di adiacenza 10

347 Visite di grafi 11

348 Scopo e tipi di visita Una visita (o attraversamento) di un grafo G permette di esaminare i nodi e gli archi di G in modo sistematico Problema di base in molte applicazioni Esistono varie tipologie di visite con diverse proprietà. In particolare: visita in ampiezza (BFS = Breadth First Search) visita in profondità (DFS = Depth First Search) 12

349 Algoritmo di visita generica 13

350 Osservazioni Un vertice viene marcato quando viene incontrato per la prima volta: marcatura implementata tramite un vettore di bit di marcatura Visita genera un albero di copertura T del grafo Insieme di vertici F T mantiene la frangia di T: v (T-F) : v è chiuso, tutti gli archi incidenti su v sono stati esaminati v F : v è aperto, esistono archi incidenti su v non ancora esaminati 14

351 Costo della visita Tempo di esecuzione dipende da struttura dati usata per rappresentare il grafo: Lista di archi: O(m n) Liste di adiacenza: O(m + n) Matrice di adiacenza: O(n 2 ) 15

352 Casi particolari di visite Se frangia F implementata come coda si ha visita in ampiezza (BFS) Se frangia F implementata come pila si ha visita in profondità (DFS) 16

353 Visita in ampiezza 17

354 Visita in ampiezza 18

355 Esempio: grafo non orientato (1/2) 19

357 Esempio: grafo orientato 21

358 Proprietà Per ogni nodo v, il livello di v nell albero BFS è pari alla distanza di v dalla sorgente s Per ogni arco (u,v) di un grafo non orientato, gli estremi u e v appartengono allo stesso livello o a livelli consecutivi dell albero BFS Se il grafo è orientato, possono esistere archi (u,v) che attraversano all indietro più di un livello 22

359 Visita in profondità 23

360 Visita in profondità 24

363 Esempio: grafo orientato (1/2) 27

364 Esempio: grafo orientato (2/2) 28

365 Proprietà Sia (u,v) un arco di un grafo non orientato. Allora: (u,v) è un arco dell albero DFS, oppure i nodi u e v sono l uno discendente/antenato dell altro Sia (u,v) un arco di un grafo orientato. Allora: (u,v) è un arco dell albero DFS, oppure i nodi u e v sono l uno discendente/antenato dell altro, oppure (u,v) è un arco trasversale a sinistra, ovvero il vertice v è in un sottoalbero visitato precedentemente ad u 29

366 Riepilogo Nozione di grafo e terminologia Diverse strutture dati per rappresentare grafi nella memoria di un calcolatore L utilizzo di una particolare rappresentazione può avere un impatto notevole sui tempi di esecuzione di un algoritmo su grafi (ad esempio, nella visita di un grafo) Algoritmo di visita generica e due casi particolari: visita in ampiezza e visita in profondità 30

367 Algoritmi e Strutture Dati Capitolo 12 Minimo albero ricoprente

368 Definizioni Sia G = (V, E) un grafo connesso non orientato. Un albero ricoprente di G è un sottografo T G tale che: T è un albero; T contiene tutti i vertici di G. Sia w(x,y) il costo (o peso) di un arco (x,y) E. Il costo di un albero è la somma dei costi dei suoi archi. Un minimo albero ricoprente di G è un albero ricoprente di costo minimo. 2

369 Esempi Il minimo albero ricoprente non è necessariamente unico 3

370 Proprietà di minimi alberi ricoprenti 4

371 Tagli e cicli Dato un grafo non orientato G = (V,E), un taglio in G è una partizione dei vertici V in due insiemi: X e V-X. Un arco e = (u,v) attraversa il taglio (X,X) se u X e v X Un ciclo è un cammino in cui il primo e l ultimo vertice coincidono 5

372 Un approccio goloso Costruiremo un minimo albero ricoprente un arco alla volta, effettuando scelte localmente golose. Ad esempio: includere nella soluzione archi di costo piccolo escludere dalla soluzione archi di costo elevato Formalizzeremo il processo come un processo di colorazione: archi blu: inclusi nella soluzione archi rossi: esclusi dalla soluzione 6

373 Regola del taglio (Regola blu) Scegli un taglio che non contiene archi blu. Tra tutti gli archi non colorati del taglio, scegline uno di costo minimo e coloralo blu. Ogni albero ricoprente deve infatti contenere almeno un arco del taglio E naturale includere quello di costo minimo 7

374 Regola del ciclo (Regola rossa) Scegli un ciclo che non contiene archi rossi. Tra tutti gli archi non colorati del ciclo, scegline uno di costo massimo e coloralo rosso. Ogni albero ricoprente deve infatti escludere almeno un arco del ciclo E naturale escludere quello di costo massimo 8

375 L approccio goloso L approccio goloso applica una delle due regole ad ogni passo, finché tutti gli archi sono colorati Si può dimostrare che esiste sempre un minimo albero ricoprente che contiene tutti gli archi blu e non contiene nessun arco rosso. Si può inoltre dimostrare che il metodo goloso colora tutti gli archi. 9

376 Tempi di esecuzione A seconda della scelta della regola da applicare e del taglio/ciclo usato ad ogni passo, si ottengono dal metodo goloso diversi algoritmi con diversi tempi di esecuzione 10

377 Algoritmo di Kruskal 11

378 Strategia Mantieni foresta di alberi blu, all inizio tutti disgiunti Per ogni arco, in ordine non decrescente di costo, applica il passo seguente : se l arco ha entrambi gli estremi nello stesso albero blu, applica regola del ciclo e coloralo rosso, altrimenti applica regola del taglio e coloralo blu I vertici nello stesso albero blu sono mantenuti tramite una struttura dati union/find 12

379 Pseudocodice 13

380 Esempio (1/2) 14

381 Esempio (2/2) 15

382 Analisi Il tempo di esecuzione dell algoritmo di Kruskal è O(m log n) nel caso peggiore (Utilizzando un algoritmo di ordinamento ottimo e la struttura dati union-find) 16

383 Algoritmo di Prim 17

384 Strategia Mantiene un unico albero blu T, che all inizio consiste di un vertice arbitrario Applica per (n-1) volte il seguente passo: scegli un arco di costo minimo incidente su T e coloralo blu (regola del taglio) Definiamo arco azzurro un arco (u,v) tale che u T, v T, e (u,v) ha il costo minimo tra tutti gli archi che connettono v ad un vertice in T: l algoritmo mantiene archi azzurri in una coda con priorità da cui viene estratto il minimo ad ogni passo 18

385 Pseudocodice 19

386 Esempio (1/2) 20

387 Esempio (2/2) 21

388 Analisi Il tempo di esecuzione dell algoritmo di Prim è O(m + n log n) nel caso peggiore (Realizzando la coda con priorità tramite heap di Fibonacci) 22

389 Algoritmo di Boruvka 23

390 Strategia Mantiene una foresta di alberi blu, all inizio tutti disgiunti Ad ogni passo, applica la regola seguente: per ogni albero blu T nella foresta, scegli un arco di costo minimo incidente su T e coloralo blu (regola del taglio) Per non rischiare di introdurre cicli, assumiamo che i costi degli archi siano tutti distinti Non è necessario usare strutture dati sofisticate 24

391 Esempio 25

392 Analisi Il tempo di esecuzione dell algoritmo di Boruvka è O(m log n) nel caso peggiore (Senza usare strutture dati sofisticate) 26

393 Riepilogo Paradigma generale per il calcolo di minimi alberi ricoprenti Applicazione della tecnica golosa Tre algoritmi specifici ottenuti dal paradigma generale: Prim, Kruskal e Boruvka L uso di strutture dati sofisticate ci ha permesso di implementare tali algoritmi in modo efficiente 27

394 Algoritmi e Strutture Dati Capitolo 13 Cammini minimi

395 Definizioni Sia G = (V,E) un grafo orientato pesato sugli archi. Il costo di un cammino π = <v 0,v 1,v 2,,v k > è dato da: Un cammino minimo tra una coppia di vertici x e y è un cammino di costo minore o uguale a quello di ogni altro cammino tra gli stessi vertici. 2

396 Proprietà dei cammini minimi Sottostruttura ottima: ogni sottocammino di un cammino minimo è anch esso minimo Grafi con cicli negativi: se due vertici x e y appartengono a un ciclo di costo negativo, non esiste nessun cammino minimo finito tra di essi Se G non contiene cicli negativi, tra ogni coppia di vertici connessi in G esiste sempre un cammino minimo semplice, in cui cioè tutti i vertici sono distinti 3

397 Distanza fra vertici La distanza d xy tra due vertici x e y è il costo di un cammino minimo da x a y (o + se i due vertici non sono connessi) Disuguaglianza triangolare: per ogni x, y e z Condizione di Bellman: per ogni arco (u,v) e per ogni vertice s 4

398 Alberi di cammini minimi Un arco (u,v) appartiene a un cammino minimo a partire da un vertice s se e solo se u è raggiungibile da s e d su + w(u,v) = d sv I cammini minimi da un vertice s a tutti gli altri vertici del grafo possono essere rappresentati tramite un albero radicato in s, detto albero dei cammini minimi 5

399 Calcolare cammini minimi da distanze Problema: Le distanze non sono note (è proprio quello che vogliamo trovare!) 6

400 Tecnica del rilassamento Partiamo da stime per eccesso delle distanze D xy d xy e aggiorniamole decrementandole progressivamente fino a renderle esatte. Aggiorniamo le stime basandoci sul seguente passo di rilassamento: 7

401 Algoritmo generico per il calcolo delle distanze Rilassamento 8

402 Algoritmo di Bellman e Ford (per cammini minimi a sorgente singola) 9

403 Ordine di rilassamento Sia π = < s,v 1,v 2,,v k > un cammino minimo. Se fossimo in grado di eseguire i passi di rilassamento nell ordine seguente: in k passi avremmo la soluzione. Purtroppo non conosciamo l ordine giusto, essendo π ignoto! 10

404 Approccio di Bellman e Ford Esegui n passate In ciascuna passata rilassa tutti gli archi Dopo la j-esima passata, i primi j rilassamenti corretti sono stati certamente eseguiti Esegue però molti rilassamenti inutili! 11

405 Pseudocodice Tempo di esecuzione: O(n m) 12

406 Algoritmo per grafi diretti aciclici (per cammini minimi a sorgente singola) 13

407 Ordinamento topologico Funzione σ: V {1, n} tale che σ(u) < σ(v) se esiste un cammino da u a v in G Esiste se e solo se G è aciclico 14

408 Calcolo di un ordinamento topologico Tempo di esecuzione: O(n+m) 15

409 Cammini minimi in grafi aciclici Eseguire i rilassamenti in ordine topologico Tempo di esecuzione: O(n+m) 16

410 Algoritmo di Dijkstra (per cammini minimi a sorgente singola in grafi con costi non negativi) 17

411 Estendere l albero dei cammini minimi Sia T un albero dei cammini minimi radicato in s che non include tutti i vertici raggiungibili da s, sia (u,v) t.c. u T e v T, e t.c. (u,v) minimizza la quantità d su + w(u,v) : allora (u,v) appartiene a un cammino minimo da s a v 18

Vedere altro