Appunti di Algoritmi e Strutture Dati. Alberto Carraro

Transcript

1 Appunti di Algoritmi e Strutture Dati Alberto Carraro

2 2

3 Contents 1 Introduzione informale agli algoritmi I numeri di Fibonacci Algoritmo numerico Algoritmo ricorsivo Algoritmo iterativo Algoritmo basato su potenze ricorsive Modelli di calcolo e metodologie di analisi Criteri di costo La notazione asintotica Delimitazioni inferiori e superiori Metodi di analisi Analisi di algoritmi ricorsivi Metodo di iterazione Metodo di sostituzione Il teorema fondamentale delle ricorrenze Analisi dell albero della ricorsione Cambiamenti di variabile Analisi ammortizzata Metodo dell aggregazione Metodo degli accantonamenti Metodo del potenziale Esercizi Correttezza degli algoritmi Algoritmi iterativi Algoritmi ricorsivi Pile e code Pile Code Esercizi Liste Esercizi Alberi Introduzione Rappresentazioni Rappresentazioni indicizzate Rappresentazioni collegate Visite Visita in profondità Visita in ampiezza Alberi binari di ricerca Esercizi

4 6.6 Alberi AVL Ribilanciamento tramite rotazioni Alberi di Fibonacci Heap e code di priorità Heap Costruzione Realizzazione Code di priorità Algoritmi di ordinamento Selection sort Insertion sort Bubble sort Heap sort Merge sort Quicksort Counting sort Radix sort Limitazione inferiore per algoritmi basati sul confronto Tabelle hash Definizione di funzioni hash Risoluzione delle collisioni Liste di collisione Indirizzamento aperto Tecniche algoritmiche Divide et impera Programmazione dinamica Paradigma greedy Grafi Definizioni preliminari Rappresentazione di grafi Lista di archi Liste di adiacenza Matrice di adiacenza Confronto tra le rappresentazioni Visite di grafi Minimo albero ricoprente Teorema fondamentale Algoritmo di Kruskal Algoritmo di Prim Cammini minimi con sorgente singola Cammini minimi e rilassamento Algoritmo di Dijkstra Algoritmo di Bellman-Ford Cammini minimi fra tutte le coppie Cammini minimi e moltiplicazione di matrici Algoritmo di Floyd-Warshall

5 15 Reti di flusso Introduzione Problema del flusso massimo Flusso massimo - taglio minimo Algoritmo di Ford-Fulkerson Ottimizzazione di Edmond-Karp Abbinamento massimo nei grafi bipartiti Caso di studio: segmentazione di immagini String matching Introduzione Algoritmo ingenuo String matching con automa a stati finiti Automi a stati finiti L algoritmo Costruzione dell automa Algoritmo di Knuth - Morris - Pratt Geometria computazionale Intersezione tra segmenti Ricerca di un intersezione tra diversi segmenti Inviluppo convesso Algoritmo brute force Algoritmo di Jarvis Algoritmo di Graham Algoritmo Quick Hull Teoria della NP-completezza Complessità di problemi decisionali Classi di complessità La classe NP Non determinismo La gerarchia Riducibilità polinomiale Problemi NP-completi La classe conp e la relazione tra P e NP Appendice Serie aritmetica Serie geometrica Calcolo di somme per integrazione Goniometria e trigonometria

6 6

7 Chapter 1 Introduzione informale agli algoritmi Definizione 1.1. Un algoritmo è un insieme di istruzioni, definite passo per passo, in modo tale da poter essere eseguite meccanicamente, e tali da produrre un determinato risultato. 1.1 I numeri di Fibonacci Si vuole scrivere un algoritmo per il calcolo dell n-esimo numero di Fibonacci, che può essere calcolato utilizzando la seguente formula: { 1 se n = 1, 2 F n = (1.1) F n 1 + F n 2 se n 3 Saranno presentati diversi algoritmi, evidenziandone pregi e difetti Algoritmo numerico Un primo algoritmo si basa sull utilizzo di una funzione matematica che calcoli direttamente i numeri di Fibonacci; proviamo a vedere se è possibile individuarne una esponenziale della forma a n con a 0 che soddisfi la relazione di ricorrenza 1.1: a n = a n 1 + a n 2 a n 2 (a 2 a 1) = 0 Poiché, per ipotesi, a 0, cerchiamo i valori di a che soddisfano l equazione: L equazione 1.2 ammette due radici reali: a 2 a 1 = 0 (1.2) φ = ˆφ = Le funzioni φ n e ˆ φ n soddisfano entrambe la relazione (1.1), ma nessuna di esse calcola correttamente i numeri di Fibonacci come vorremmo: ad esempio, φ 2 F 2 ; questo perché non sono stati considerati i passi base della definizione ricorsiva. Per risolvere il problema, è sufficiente osservare che una qualunque combinazione lineare di funzioni che soddisfano la relazione di Fibonacci soddisfa anch essa tale relazione; cerchiamo opportune costanti c 1 e c 2 che diano la funzione cercata: { c 1 φ + c 2 ˆφ = 1 c 1 φ 2 + c 2 ˆφ 2 = 1 Risolvendo il sistema si ottiene: 7

8 c 1 = c 2 = 1 5 Segue che il primo algoritmo per il calcolo dei numeri di Fibonacci è il seguente: 1 int fibonaccinumerico ( int n){ 1 2 return 5 (φ n φ ˆn ); 3 } Algoritmo Fibonacci numerico Il limite di tale algoritmo è dato dal fatto che si è costretti ad operare con numeri reali, rappresentati nei calcolatori con precisione limitata, e quindi si possono fornire risposte errate dovute ad errori di arrotondamento Algoritmo ricorsivo Data la natura ricorsiva della relazione di Fibonacci, si può pensare di realizzare un algoritmo ricorsivo, come il seguente: 1 int fibonacciricorsivo ( int n){ 2 if (n <= 2) 3 return 1; 4 else Algoritmo Fibonacci ricorsivo 5 return fibonacciricorsivo (n -1) + fibonacciricorsivo (n -2) ; 6 } Per analizzare le prestazioni di un algoritmo, si possono considerare il numero di linee di codice eseguite (complessità temporale) e la quantità di memoria occupata (complessità spaziale): consideriamo la prima. In generale, ogni algoritmo ricorsivo può essere analizzato mediante una relazione di ricorrenza: il tempo speso da una routine è pari al tempo speso all interno della routine più quello speso dalle chiamate ricorsive; ad esempio, la relazione per l algoritmo sopra descritto, per n > 2, è la seguente: T (n) = 2 + T (n 1) + T (n 2) Possiamo rappresentare le chiamate ricorsive con una struttura ad albero, detta albero di ricorsione: si usa un nodo, la radice dell albero, per la prima chiamata e generiamo un figlio per ogni chiamata ricorsiva. F 5 = 5 F4 = 3 F3 = 2 F3 = 2 F2 = 1 F2 = 1 F 1 = 1 F2 = 1 F 1 = 1 Figure 1.1: Albero di ricorsione di fibonacciricorsivo per il calcolo di F 5 Per calcolare il numero di linee di codice eseguite da una generica chiamata fibonacciricorsivo(n) usiamo i seguenti lemmi. Lemma 1.1. Sia T n l albero delle chiamate ricorsive della funzione fibonacciricorsivo(n): il numero di foglie in T n è pari al numero di Fibonacci F n. Proof. Procediamo per induzione su n. 8

9 Caso base: è banalmente verificato; per n = 1, T 1 contiene un solo nodo, e dunque una sola foglia (F 1 = 1) e, per n = 2, T 2 contiene anch esso un solo nodo, e quindi una sola foglia (F 2 = 1). Ipotesi induttiva: sia n > 2 e supponiamo che il lemma sia verificato per ogni k tale per cui 2 k n 1. Passo induttivo: usando l ipotesi, dimostriamo che il lemma vale per n. L albero della ricorsione T n ha come sottoalbero sinistro T n 1 e come sottoalbero destro T n 2 : per ipotesi essi hanno, rispettivamente, F n 1 e F n 2 foglie, dunque T n ha F n 1 + F n 2 = F n foglie, come si voleva dimostrare. Lemma 1.2. Sia T un albero binario in cui ogni nodo interno ha esattamente due figli: allora il numero di nodi interni di T è pari al numero di foglie diminuito di uno. Proof. Procediamo per induzione su n. Caso base: se n = 1, T ha una sola foglia e nessun nodo interno, quindi la condizione è verificata. Ipotesi induttiva: supponiamo per ipotesi che la condizione valga per tutti gli alberi con meno di n nodi. Passo induttivo: proviamo che la condizione valga anche per T, ossia che i = f 1, dove i è il numero di nodi interni di T e f il numero di foglie di T ; sia ˆT un albero ottenuto da T rimuovendo una qualunque coppia di foglie aventi lo stesso padre: ˆT avrà i 1 nodi interni e f = f 1 foglie. Per ipotesi, poiché ˆT ha meno nodi di T, vale la relazione i 1 = (f 1) 1: sommando uno ad ambo i membri, si ottiene i = f 1, ossia l uguaglianza che si voleva dimostrare. Alla luce di quanto appena dimostrato, la chiamata generica fibonacciricorsivo(n) comporta l esecuzione di F n righe di codice per via delle foglie (una per ciascuna foglia) e 2 (F n 1) righe per via dei nodi interni (due per ciascuno), per un totale di 3 F n 2 righe di codice, una soluzione assai inefficiente Algoritmo iterativo La lentezza di fibonacciricorsivo è dovuta al fatto che continua a ricalcolare ripetutamente la soluzione dello stesso sottoproblema (vedi, ad esempio, F 3 nell albero di ricorsione in figura 1.1); per fare di meglio, si potrebbe risolvere il sottoproblema una volta sola, memorizzarne la soluzione ed usarla nel seguito invece di ricalcolarla: questa è l idea che sta alla base della tecnica chiamata programmazione dinamica. 1 int fibonacciiterativo ( int n){ 2 int Fib [n]; 3 Fib [0] = Fib [1] = 1; 4 for ( int i = 2; i < n; i ++) 5 Fib [i] = Fib [i -1] + Fib [i -2]; 6 return Fib [ n] 7 } Algoritmo Fibonacci iterativo Per quanto riguarda l analisi temporale, occorre operare in maniera diversa: per ogni linea di codice, calcoliamo quante volte essa è eseguita, esaminando a quali cicli appartiene e quante volte essi sono eseguiti. Nel nostro caso si ha: T (n) = { 4 se n = 1, 2 2n se n > 2 Si tratta di una soluzione decisamente più efficiente dell algoritmo ricorsivo proposto. 9

10 Un piccolo miglioramento L algoritmo fibonacciiterativo richiede una quantità di spazio di memoria linearmente proporzionale alla dimensione dell input n, anche se ogni iterazione utilizza solo i due valori precedenti a F n, F n 1 e F n 2 ; rimpiazzando l array con due variabili, come proposto nel seguente algoritmo, otteniamo un notevole risparmio di memoria. 1 int fibonacciiterativomodificato ( int n){ 2 int a = 1, b = 1; 3 for ( int i =2; i<n; i ++) { 4 c = a + b; 5 a = b; 6 b = c; 7 } 8 return b; 9 } Algoritmo Fibonacci iterativo modificato Algoritmo basato su potenze ricorsive L algoritmo che sarà presentato in questa sezione si basa sul seguente lemma. ( ) ( ) n 1 ( ) Lemma 1.3. Sia A =. Allora A 1 0 n 1 Fn F = = n F n 1 F n 2 Proof. Procediamo per induzione su n. Caso base: sia F 0 = 0 fissato per convenzione. Per n = 2 il caso base è banalmente verificato: ( ) 1 ( ) 1 1 F2 F = F 1 F 0 Ipotesi induttiva: supponiamo valido il lemma per n 1, ossia: ( ) n 2 ( ) 1 1 Fn 1 F = n F n 2 F n 3 Passo induttivo: dimostriamo la validità del lemma per n: ( ) n 1 ( ) ( ) 1 1 A n 1 Fn 1 F = = n = 1 0 F n 2 F n ( ) Fn 1 + F n 2 F n 1 = F n 2 + F n 3 F n 2 ( ) Fn F n 1 F n 1 F n 2 Usando il lemma appena dimostrato ed utilizzando il metodo dei quadrati ripetuti per il calcolo della potenza n-esima della matrice, si ottiene il seguente algoritmo: 1 int fibonaccimatrice ( ) ( int n){ M = potenzadimatrice (M, n - 1) 4 return M [0][0] 5 } Algoritmo Fibonacci con matrici 6 void potenzadimatrice ( int [][] M, int n) 7 if (n > 1) { 8 potenzadimatrice (M, n / 2) 9 M = M * M 10 } 11 if (n dispari ( ){ ) M = M * } 10

11 L algoritmo presenta la seguente relazione di ricorrenza: { O(1) se n 1 T (n) = T (n/2) + O(1) se n > 1 la cui soluzione è: T (n) = O(log n) 11

12 12

13 Chapter 2 Modelli di calcolo e metodologie di analisi 2.1 Criteri di costo Il criterio di misurazione del tempo di esecuzione di un algoritmo che si basa sull assunzione che le diverse operazione richiedano tutte lo stesso tempo, indipendentemente dalla dimensione degli operandi coinvolti, è noto come misura di costo uniforme; si tratta di un criterio utile in prima approssimazione, ma si tratta di un modello troppo idealizzato. Per ovviare a questo problema, è stato proposto un criterio, noto come misura di costo logaritmico, che assume che il costo di esecuzione delle operazioni dipenda dalla dimensione degli operandi coinvolti; nonostante fornisca una buona approssimazione, in svariati casi può generare una complessità eccessiva e non necessaria. 2.2 La notazione asintotica Definizione 2.1. Data una funzione f(n), definiamo: O(f(n)) = {g(n) : c > 0 n 0 0 : g(n) cf(n), n n 0 } (g(n) cresce al più come f(n)); Ω(f(n)) = {g(n) : c > 0 n 0 0 : g(n) cf(n), n n 0 } (g(n) cresce almeno come f(n)); Θ(f(n)) = {g(n) : c 1, c 2 > 0 n 0 0 : c 1 g(n) f(n) c 2 g(n), n n 0 } (g(n) cresce esattamente come f(n)). Proprietà 2.1. Date due funzioni f(n) e g(n), risulta g(n) = Θ(f(n)) se e solo se g(n) = O(f(n)) e g(n) = Ω(f(n)). Proprietà 2.2. Θ gode della proprietà simmetrica: g(n) = Θ(f(n)) se e solo se f(n) = Θ(g(n)). Proprietà 2.3. O, Ω sono simmetriche trasposte: f(n) = Ω(g(n)) se e solo se g(n) = O(f(n)). Proprietà 2.4. Per tutte e tre le notazioni vale la proprietà transitiva: per la notazione O, ad esempio, f(n) = O(g(n)) g(n) = O(h(n)) f(n) = O(h(n)). Teorema 2.1. Siano f(n) e g(n) funzioni positive: f(n) lim n + g(n) = + M > 0 n 0 > 0 : f(n) g(n) M, n n 0 f(n) M g(n) f(n) = Ω(g(n)) g(n) = O(f(n)) f(n) lim n + g(n) = 0 preso ɛ > 0, n 0 > 0 : f(n) g(n) ɛ, n n 0 f(n) ɛ g(n) f(n) = O(g(n)) g(n) = Ω(f(n)) 13

14 f(n) lim n + g(n) = l 0 preso ɛ > 0, n 0 > 0 : f(n) g(n) l ɛ, n n0 ɛ f(n) g(n) l ɛ l ɛ f(n) g(n) l + ɛ (l ɛ) g(n) f(n) (l + ɛ) g(n) f(n) = Θ(g(n)) 2.3 Delimitazioni inferiori e superiori Definizione 2.2. Un algoritmo A ha costo di esecuzione O(f(n)) su istanze di ingresso di dimensione n e rispetto ad una certa risorsa di calcolo, se la quantità r di risorsa sufficiente per eseguire A su una qualunque istanza di dimensione n verifica la relazione r(n) = O(f(n)). Definizione 2.3. Un problema P ha complessità O(f(n)) rispetto ad una data risorsa di calcolo se esiste un algoritmo che risolve P il cui costo di esecuzione rispetto a quella risorsa è O(f(n)). Definizione 2.4. Un algoritmo A ha costo di esecuzione Ω(f(n)) su istanze di dimensione n e rispetto ad una certa risorsa di calcolo, se la massima quantità r di risorsa necessaria per eseguire A su istanze di dimensione n verifica la relazione r(n) = Ω(f(n)). Definizione 2.5. Un problema P ha complessità Ω(f(n)) rispetto ad una data risorsa di calcolo se ogni algoritmo che risolve P ha costo di esecuzione Ω(f(n)) rispetto a quella risorsa. Definizione 2.6. Dato un problema P con complessità Ω(f(n)) rispetto ad una data risorsa di calcolo, un algoritmo che risolve P è ottimo se ha costo di esecuzione O(f(n)) rispetto a quella risorsa. 2.4 Metodi di analisi Per analizzare il tempo di esecuzione di un algoritmo, solitamente si usa distinguere fra tre diverse categorie di istanze, a parità di dimensione; sia T (I) il tempo di esecuzione dell algoritmo sull istanza I: Caso peggiore: Caso migliore: T worst (n) = T best (n) = max T (I) istanze di dimensione n min T (I) istanze di dimensione n Caso medio: sia P (I) la probabilità di occorrere dell istanza I: T avg (n) = istanze di dimensione n 2.5 Analisi di algoritmi ricorsivi Metodo di iterazione (T (I) P (I)) L idea è quella di ridurre la ricorsione ad una sommatoria dipendente solo dalla dimensione del problema iniziale. Esempio 2.1. Sia data la seguente relazione di ricorrenza e assumiamo, per semplicità di analisi, che n sia una potenza di 3: { 1 se n = 1 T (n) = 9 T (n/3) + n se n > 1 Srotolando la ricorsione otteniamo: 14

15 T (n) = 9 T (n/3) + n = 9 (9 T (n/9) + n/3) + n = 9 2 T (n/3 2 ) + 9 n/3 + n =... i 1 = 9 i T (n/3 i ) + (9/3) j n Dal momento che n/3 i = 1 quando i = log 3 n, risulta: j=0 log 3 n 1 T (n) = 9 log3n + n Poiché log 3 n = log 9 n log 3 9, risulta 9 log 3 n = 9 log 9 n log 3 9 = n 2 ; usando la serie geometrica, si ottiene: Metodo di sostituzione T (n) = n 2 + 3log 3 n j=0 3 j = n 2 + n 1 2 = Θ(n 2 ) L idea è di intuire la soluzione della relazione di ricorrenza ed utilizzare il principio di induzione per dimostrare che l intuizione è corretta. Esempio 2.2. Sia data la seguente relazione di ricorrenza: T (n) = { 1 se n = 1 T ( n/2 ) + n se n > 1 Intuizione: T (n) = O(n), ossia dimostrare che esistono c > 0 e n 0 > 0 tali che T (n) c n, n n 0 Passo base: provo n = 1 T (1) = 1 c 1 c 1 Ipotesi induttiva: supponiamo di avere c > 0 tale per cui T ( n/2 ) c n/2. Passo induttivo: sia n > 1 T (n) = T ( n/2 ) + n c n/2 + n c n 2 + n Rimane da provare che c n 2 + n c n; ciò risulta essere vero per c 2. Affinché siano verificati sia il caso base che il passo induttivo, occorre prendere una qualsiasi c 2. Esempio 2.3. Per illustrare altre sottigliezze relative all uso del metodo di sostituzione, consideriamo la seguente relazione di ricorrenza: T (n) = { 1 se n = 1, 2 9 T ( n/3 ) + n se n > 2 Intuizione: T (n) = O(n 2 ), ossia dimostrare che esistono c > 0 e n 0 > 0 tali che T (n) c n 2, n n 0 Passo base: T (1) = T (2) = 1 c 1 2 c 2 2 c 1 Ipotesi induttiva: assumiamo che la disuguaglianza sia soddisfatta per ogni k < n 15

16 Passo induttivo: sia n > 2 T (n) = 9 T ( n/3 ) + n 9 c n/3 2 + n 9 c (n/3) 2 + n = c n 2 + n Usando questa soluzione, non riusciamo a dimostrare la nostra affermazione poiché c n 2 + n > c n 2 ; possiamo risolvere facilmente il problema usando un ipotesi induttiva più forte, in modo da far comparire un addendo negativo negativo che, sommato ad n, faccia tornare i conti; provando con l ipotesi T (n) c (n 2 n) otteniamo: T (n) = 9 T ( n/3 ) + n 9 c ((n/3) 2 n/3) + n = c n 2 3 c n + n Rimane da provare che c n 2 3 c n + n c (n 2 n); ciò risulta essere vero per c 1/2. Abbiamo, però, un altro problema: il passo base non è più verificato; infatti T (1) = 1 > c (1 2 1) = 0; ciò può essere risolto cambiando n 0, che prima avevamo scelto pari a 1. Poiché T (2) = 1 c (4 2) per c 1/2, vediamo se possiamo scegliere n 0 = 2: per poterlo fare, dobbiamo definire tutti i casi che si riconducono a T (1) come casi base e verificare che, per tutti questi, esista c che verifichi la nostra condizione; in particolare, in questo esempio, dobbiamo definire come passi base T (3), T (4), T (5), oltre a T (2) (per n 6 ci si riconduce a un caso per cui la condizione valga): T (3) = 9 T (1) + 3 = 12 c (3 2 3) per c 2 T (4) = 9 T (1) + 4 = 13 c (4 2 4) per c 13/12 T (5) = 9 T (1) + 5 = 14 c (5 2 5) per c 7/10 Affinché siano verificati tutti i casi base e il passo induttivo, dobbiamo avere n 0 = 2 e c Il teorema fondamentale delle ricorrenze Si tratta di un metodo per analizzare algoritmi basati sulla tecnica del dividi et impera, in cui: un problema di dimensione n viene diviso in a sottoproblemi di dimensione n/b; dividere in sottoproblemi e combinare le soluzioni richiede tempo f(n). La relazione di ricorrenza corrispondente a questo scenario è la seguente: ( n ) T (n) = a T + f(n) (2.1) b Per analizzare la relazione di ricorrenza, consideriamo l albero della ricorsione ed assumiamo che n sia una potenza esatta di b e che la ricorsione si fermi quando n = 1. Proprietà 2.5. I sottoproblemi al livello i dell albero della ricorsione hanno dimensione n/b i. Proprietà 2.6. Il contributo di un nodo di livello i al tempo di esecuzione (escluso il tempo speso nelle chiamate ricorsive) è f(n/b i ). Proprietà 2.7. Il numero di livelli nell albero della ricorsione è log b n. Proprietà 2.8. Il numero di nodi al livello i dell albero della ricorsione è a i. Usando le proprietà appena elencate, si può riscrivere la relazione di ricorrenza nella seguente forma: T (n) = log b n i=0 ( n ) a i f b i La soluzione della (2.2) è data dal seguente teorema, noto come teorema fondamentale delle ricorrenze. (2.2) 16

17 Teorema 2.2. La relazione di ricorrenza { 1 se n = 1 T (n) = a T (n/b) + f(n) se n > 1 ha soluzione: 1. T (n) = Θ(n log b a ), se f(n) = O(n log b a ɛ ) per ɛ > 0; 2. T (n) = Θ(n log b a log n), se f(n) = Θ(n log b a ); 3. T (n) = Θ(f(n)), se f(n) = Ω(n log b a+ɛ ) per ɛ > 0 e a f(n/b) c f(n) per c < 1 ed n sufficientemente grande. Proof. Assumiamo per semplicità che n sia una potenza esatta di b. Caso 1: riscriviamo il termine generico della sommatoria 2.2: ( n ) ( ( n ) a i f b i = O a i logb a ɛ) ( b i = O n log b a ɛ ( a b ɛ b log b a ) i ) = O(n log b a ɛ (b ɛ ) i ) Per limitare superiormente T (n) si può scrivere: ( ) ( ( log b n log b n T (n) = O(n log b a ɛ (b ɛ ) i ) = O n log b a ɛ (b ɛ ) i = O n log b a ɛ O ( i=0 n log b a ɛ ( i=0 )) b ɛ n ɛ 1 b ɛ = O(n log b a ɛ n ɛ ) = O(n log b a ) 1 )) b ɛ (log b n+1) 1 b ɛ = 1 Analizzando l equazione 2.2 e considerando solo i tempi di esecuzione relativi ai nodi sull ultimo livello dell albero di ricorsione, otteniamo: T (n) a log b n = n log b a T (n) = Ω(n log b a ) Dalle due limitazioni segue che T (n) = Θ(n log b a ). Caso 2: anche in questo caso, riscriviamo il termine generico della sommatoria: ( n ) ( ( n ) a i f b i = Θ a i logb a) ( ( b i = Θ n log b a ) i ) a b log b a = Θ(n log b a ) Da cui segue: T (n) = log b n i=0 Θ(n log b a ) = Θ(n log b a log b n). Caso 3: sotto l assunzione a f(n/b) c f(n), risulta facile dimostrare che a i f(n/b i ) c i f(n); infatti: ( n ) ( n/b a i f b i = a i 1 i 1 ) ( n ) a f a i 1 c f b b i 1 Iterando il ragionamento si ottiene la disuguaglianza desiderata. Usando l equazione 2.2, la serie geometrica con base c < 1 e la disuguaglianza appena dimostrata, si può scrivere: T (n) = log b n i=0 ( n ) a i f b i f(n) c i = f(n) i=0 1 1 c = O(f(n)) Dalla relazione 2.2, si ricava immediatamente che T (n) = Ω(f(n)), da cui T (n) = Θ(f(n)). Esempio 2.4. Consideriamo la seguente relazione di ricorrenza: { O(1) se n = 1 T (n) = T (n/2) + O(1) altrimenti Si ha f(n) = O(1) = Θ(n log 2 1 ); ci troviamo, dunque, nel caso 2 del teorema, e quindi risulta T (n) = Θ(log n). 17

18 Esempio 2.5. Consideriamo la seguente relazione di ricorrenza: { O(1) se n = 1, 2 T (n) = 9 T (n/3) + n altrimenti Si ha f(n) = n = O(n log 3 9 ɛ ); dal caso 1 del teorema fondamentale, risulta che T (n) = Θ(n 2 ). Esempio 2.6. Consideriamo la seguente relazione di ricorrenza: { O(1) se n = 1 T (n) = T (n/2) + n + log n +1 Si ha f(n) = n+log n+1 = Θ(n) = Ω(n log 2 1 ɛ ), che può ricadere nel caso 3 del teorema fondamentale; occorre infatti trovare c < 1 tale che, per n sufficientemente grande, valga: Esisterà n 0 tale che, per n n 0, si ha a f(n/b) c f(n) ( n log n ) c (n + log n + 1) n 2 c + log n (= 1 ) n + log n < 1 per n + n 2 + log n n + log n È sufficiente prendere c = 3/4 affinché la disuguaglianza del caso 3 del teorema fondamentale sia verificata per n sufficientemente grande; segue che T (n) = Θ(n). Esempio 2.7. Consideriamo la seguente relazione di ricorrenza: { O(1) se n = 1, 2 T (n) = 3 T (n/3) + n log n altrimenti Nessuno dei casi del teorema principale può essere applicato; si potrebbe pensare di utilizzare il terzo caso, ma questo non è possibile poiché n log n è solo logaritmicamente, e non polinomialmente, più grande di n log 3 3 = n Analisi dell albero della ricorsione La tecnica consiste nell analizzare l albero delle chiamate ricorsive, indicando le dimensioni dei problemi di ogni chiamata ricorsiva, ed analizzando la dimensione totale dei problemi ad ogni livello dell albero. Esempio 2.8. Consideriamo la seguente relazione di ricorrenza: { 1 se n = 1, 2 T (n) = 9 T (n/3) + n 2 log n altrimenti n 9 n/3 n/3 n/3 n/3 n/3 n/3 n/3 n/3 n/ Figure 2.1: Parte iniziale dell albero di ricorsione Calcoliamo il costo di ciascun livello dell albero di ricorsione: 18

19 Liv. 0: problema di dimensione n e costo n 2 log n totale = n 2 log n; ( ) 2 ( Liv. 1: problema di dimensione n 3 e costo n 3 log n 3 totale = 9 Liv. 2: problema di dimensione n 3 2 Liv. i: problema di dimensione n 3 e costo i n 3 ) 2 log n 3 ; ( ) 2 ( ) 2 n e costo 3 log n 2 3 totale = 9 2 n 2 3 log n 2 ( n 3 i ) 2 log n 3 i totale = 9 i Foglie: problemi di dimensione 1 n 3 k = 1 k = log 3 n. ( 3 2 ; ) n 3 2 log n i 3 = n 2 log n i n 2 log 3); i T (n) = log 3 n 1 i=0 Risulta quindi T (n) = Θ(n 2 log 2 n). (n 2 log n n 2 i log 3) } {{ } contributo nodi interni + 9 log 3 n } {{ } contributo foglie log 3 n 1 log 3 n 1 = n 2 log n 1 n 2 log 3 i + n 2 i=0 i=0 = n 2 log n log 3 n n 2 log 3 (log 3 n 1) (log 3 n) 2 = n 2 log n log 3 n n 2 log 3 log2 3 n Cambiamenti di variabile + n 2 + n 2 log 3 log 3 n 2 Si tratta di una tecnica che viene utilizzata quando la relazione di ricorrenza presenta delle radici; per maggiori informazioni, vedere l esempio. Esempio 2.9. Consideriamo la seguente relazione di ricorrenza: T (n) = { O(1) se n = 1 T ( n) + O(1) altrimenti Eseguiamo la sostituzione n = 2 x (ossia x = log n), da cui n = 2 x/2 e T (2 x ) = T (2 x/2 ) + O(1); poniamo inoltre T (2 x ) = R(x), da cui otteniamo la relazione di ricorrenza R(x) = R(x/2) + O(1), risolvibile con il teorema principale (R(x) = O(log x)). Combinando le uguaglianze T (2 x ) = O(log x) e n = 2 x, si ha T (n) = O(log log n). + n Analisi ammortizzata una tecnica usata nel campo dell analisi delle complessità per calcolare il costo medio di una singola operazione, all interno di una sequenza che può contenere operazioni molto costose, in maniera più precisa, invece di sovrastimare tutte le operazioni attribuendo loro costo massimo. Attenzione: l analisi del caso medio considera la tipologia di input medio, ovvero quello più probabile; l analisi ammortizzata non usa la teoria della probabilità, ma considera una serie di operazioni e valuta le prestazioni medie di ciascuna operazione nel caso pessimo. Nell analisi ammortizzata, si fa sostanzialmente uso di tre metodi: metodo dell aggregazione; metodo degli accantonamenti; metodo del potenziale. 19

20 In seguito, considereremo l esempio di un contatore binario: dato un array A[k 1...0] di {0, 1}, che rappresenta il numero k 1 x = (A[i] 2 i ) i=0 si vuole calcolare il costo di n incrementi, con x inizialmente a zero; l algoritmo di incremento è il seguente: 1 increment ( array A void ) 2 i = 0 3 while (i < length (A) && A[i] == 1){ 4 A[ i] = 0 5 i = i } 7 if(i < length (A)) 8 A[ i] = 1 Seguendo la tecnica di analisi tradizionale, poiché nel caso peggiore la complessità dell incremento è O(k), concludiamo che il costo di n incrementi è O(n k). Proviamo, invece, ad usare ciascuna delle tre tecniche dell analisi ammortizzata e vediamo che risultati otteniamo Metodo dell aggregazione Idea: se una sequenza di n operazioni impiega, nel caso peggiore, un tempo T (n), allora il costo ammortizzato di ogni operazione è T (n)/n. Esempio Facciamo n operazioni di increment: chiaramente non tutti i bit cambiano ad ogni chiamata. In particolare: A[0] cambia ad ogni chiamata, per un totale di n volte; A[1] cambia ogni due chiamate, per un totale di n/2 volte; A[2] cambia ogni quattro chiamate, per un totale di n/4 volte; A[i] cambia la metà delle volte di A[i 1], ossia n/2 i volte. Il numero totale di cambi in n operazioni è: T (n) = k n 2 i i=0 k n k ( 1 i 2 2) i = n ( 1 ) i n = 2 n 2 Quindi, il costo medio delle operazioni nel caso pessimo è 2 n/n = 2 = O(1). i= Metodo degli accantonamenti Idea: vengono assegnati costi diversi a operazioni differenti; qualche operazione potrebbe essere associata a un costo minore o maggiore di quello effettivo, detto costo ammortizzato. Quando il costo ammortizzato supera quello effettivo, la differenza viene trattenuta come credito: questo può essere usato successivamente per pagare operazioni il cui costo ammortizzato è minore di quello effettivo. Siano: C i : costo effettivo dell i-esima operazione; Ĉi: costo ammortizzato dell i-esima operazione; dopo n operazioni, dev essere valida la relazione: n Ĉ i i=1 Il credito totale è dato dalla seguente formula: n Ĉ i i=1 i=0 n i=1 n i=1 C i C i i=0 20

21 Esempio Definiamo i costi nel seguente modo: impostare un bit a 1 costa 2 unità; impostare un bit a 0 costa 0 unità. Il costo ammortizzato di ogni operazione di increment è 2 unità, in quanto viene impostato un solo bit a 1, mentre un numero variabile di bit a 0. Ora dobbiamo provare che il credito totale è sempre maggiore o uguale a zero; definiamo innanzitutto b i come il numero di bit a 1 dopo l i-esima operazione. Proprietà 2.9. Se ogni operazione di increment viene pagata con costo ammortizzato 2 e il contatore è inizialmente nullo, allora dopo i operazioni il credito è maggiore o uguale a b i. Proof. Procediamo per induzione su i. Caso base: si ha i = 0; il credito è 0 e b i = 0, in quanto il contatore è inizialmente nullo. Ipotesi induttiva: per k < i, il credito dopo la k-esima operazione è maggiore o uguale a b k. Passo induttivo: sia i > 0; per ipotesi si ha che il credito, dopo i 1 operazioni, è maggiore o uguale a b i 1. L operazione i-esima: deposita due unità, da cui il credito iniziale è maggiore o uguale a b i 1 + 2; imposta a zero una serie s i di bit: si ha s i b i ; se il contatore non è stato azzerato, imposta un bit a 1. Il costo effettivo della chiamata è quindi minore o uguale a s i + 1. All uscita: b i b i 1 s i + 1; il credito è dato dalla differenza tra credito iniziale e costo effettivo: Dunque il credito residuo non è mai negativo. credito b i (s i + 1) = b i 1 s i + 1 b i Metodo del potenziale Idea: rappresentiamo il credito prepagato come una sorta di energia potenziale che può essere liberata per pagare le operazioni future; il potenziale è associato alla struttura e dipende dalle operazioni fatte. dove: Fissiamo una struttura ed eseguiamo n operazioni: φ(0) è il potenziale iniziale; φ(i) è il potenziale dopo l i-esima operazione; C i è il costo dell i-esima operazione; φ : {0, 1,..., n} R Ĉi è il costo ammortizzato dell i-esima operazione. I fondi effettivi devono essere pari alle spese sostenute, ossia: Ĉ i + φ(i 1) = C i + φ(i) da cui: Ĉ i = C i + φ(i) φ(i 1) 21

22 ossia: Si ha: Vogliamo che valga: n Ĉ i = i=1 = = = = n (C i + φ(i) φ(i 1)) i=1 n C i + i=1 n i=1 n i=1 n φ(i) i=1 n φ(i 1) i=1 n 1 C i + φ(n) + φ(i) i=1 n φ(i 1) φ(0) i=2 n 1 n 1 C i + φ(n) + φ(i) φ(j) φ(0) i=1 n C i + φ(n) φ(0) i=1 n Ĉ i i=1 n i=1 C i j=1 φ(n) φ(0) 0 (2.3) Se non sappiamo quante operazioni saranno fatte, per garantire la relazione 2.3, si impone φ(i) φ(0); di solito è comodo porre φ(0) = 0 e provare φ(i) 0. Esempio Scegliamo φ(i) come il numero di bit a 1 dopo la i-esima operazione: si ha φ(0) = 0 e φ(i) 0 per ogni i > 0; abbiamo un buon potenziale, in quanto soddisfa φ(i) φ(0). Consideriamo la i-esima operazione e sia s i il numero di bit impostati a zero nel corso di questa operazione; si ha: { b i 1 s i se b i 1 = k b i = Da cui: C i = b i 1 s i + 1 { s i s i + 1 se b i 1 = k se b i 1 < k se b i 1 < k { s i + b i b i 1 se b i 1 = k Ĉ i = s i b i b i 1 se b i 1 < k { s i + b i 1 s i b i 1 se b i 1 = k = s i b i 1 s i + 1 b i 1 se b i 1 < k { 0 se b i 1 = k = 2 se b i 1 < k Scegliendo 2 come costo ammortizzato siamo a posto. 2.7 Esercizi Esercizio 2.1. Dimostrare che f(n) Θ(g(n)) sse f(n) O(g(n)) Ω(g(n)). Svolgimento: ( ) Supponiamo che f(n) Θ(g(n)). Allora esistono due costanti c 0, c 1 R + ed un numero naturale n 0 N tali che per ogni n n 0 abbiamo c 0 g(n) f(n) c 1 g(n). Il fatto che n n 0. c 0 g(n) f(n) ci dice che f(n) Ω(g(n)), mentre ( n n 0 ).f(n) c 1 g(n) implica che f(n) O(g(n)). ( ) Siccome f(n) Ω(g(n)), esistono due costanti c 0 R + e n 0 N tali che f(n) c 0 g(n), per ogni n n 0. Siccome f(n) O(g(n)), esistono due costanti c 0 R + e n 0 N tali che c 0g(n) f(n), per ogni n n 0. Sia m 0 = max(n 0, n 0). Allora c 0g(n) f(n) c 0 g(n), per ogni n m 0. Dunque f(n) Θ(g(n)). 22

23 Esercizio 2.2. Dimostrare che per n > 6 si ha F n > 2 n 2. Svolgimento: Ricordiamo la definizione ricorsiva della serie di Fibonacci: { 1 se n = 1 oppure n = 2 F n = F n 1 + F n 2 se n 3 Prodediamo dunque con una prova per induzione completa. Il caso base è n = 7. Abbiamo F 7 = 13 > = 128 perché 13 = 169. Per ipotesi induttiva ora sappiamo che F n 1 > 2 n 1 2 e F n 2 > 2 n 2 dunque F n = F n 1 + F n 2 > 2 n n 2 2 = 2 n n 2 2 > 2 n 2 poiché > 2 2. Esercizio 2.3. Dire perché il tempo di calcolo dell algoritmo Fibonacci2 (pag. 6 [1]) cresce così rapidamente al crescere di n (argomentando usando l albero di ricorsione). Svolgimento: Come dice anche il libro stesso, la formula di ricorrenza che calcola la complessità dell algoritmo definisce la funzione di Fibonacci stessa. L esercizio 2.2 ci dice che F n Ω(2 n 2 ), e pertanto l algoritmo ha complessità almeno esponenziale. Esercizio 2.4. Spiegare come l algoritmo Fibonacci3 (pag. 9 [1]) è migliore di Fibonacci2. Svolgimento: La complessità di Fibonacci3 è lineare nella dimensione dell input mentre gli esercizi 2.2,2.3 ci dicono che la complessità di Fibonacci2 è esponenziale nella dimensione dell input. Esercizio 2.5. Dimostrare che n + 10 Θ( n). Svolgimento: Dobbiamo trovare due costanti c 0, c 1 R + ed un numero naturale n 0 N tali che per ogni n n 0 abbiamo c 0 n n + 10 c1 n. Le soluzioni (nell incognita n) della disequazione c 0 n n + 10 sono n 10 (1 c 2). Scegliendo c 0 = 2 0 abbiamo n Le soluzioni (nell incognita n) della disequazione n + 10 c 1 n sono n 10 (c 2 1). Scegliendo c 1 = 2 1 abbiamo n 10. L intersezione dei due intervalli di soluzioni {n : n 10} e {n : n 10 3 } è uguale a [10, + ). Quindi se scegliamo n 0 = 10, c 0 = 2 e c 1 = 2 abbiamo che il sistema { c 0 n n + 10 n + 10 c1 n 2, è soddisfatto per ogni n n 0. Esercizio 2.6. Dimostrare che 1 2 n2 3n Θ(n 2 ). Svolgimento: Dobbiamo trovare due costanti c 0, c 1 R + ed un numero naturale n 0 N tali che per ogni n n 0 abbiamo c 0 n n2 3n c 1 n 2. Le soluzioni (nell incognita n) della disequazione c 0 n n2 3n sono n 6 1 c 0. Scegliendo c 0 = 1 2 abbiamo n 12. Le soluzioni (nell incognita n) della disequazione 1 2 n2 3n c 1 n 2 sono n 6 2c. Scegliendo c = 1 abbiamo n 6. L intersezione dei due intervalli di soluzioni {n : n 12} e {n : n 6} è uguale a [12, + ). Quindi se scegliamo n 0 = 12, c 0 = 1 2 e c 1 = 1 abbiamo che il sistema è soddisfatto per ogni n n 0. Esercizio 2.7. Dimostriamo che: (1) f(n) O(g(n)) sse g(n) Ω(f(n)) (2) f(n) Θ(g(n)) sse g(n) Θ(f(n)) Svolgimento: { c 0 n n2 3n 1 2 n2 3n c 1 n 2 23

24 (1) Supponiamo f(n) O(g(n)). Allora esistono c R + e n 0 N tali che n n 0. f(n) cg(n). Dunque, ponendo c = 1 c si ha n n 0. c f(n) g(n) e siccome c R +, abbiamo mostrato che g(n) Ω(f(n)). Il viceversa si fa in maniera analoga. (2) Basta usare il punto (1). Esercizio 2.8. Sia f una funzione per cui esiste un numero naturale n 0 tale che f(n) > 0, per ogni n n 0. Dimostriamo che per ogni a, b R +, af(n) + b Θ(f(n)). Svolgimento: Dobbiamo trovare c 1, c 2, n 0 tali che n n 0. c 1 f(n) af(n) + b c 2 f(n). Scegliamo c 1 = a e c 2 = a + b. Allora af(n) af(n) + b af(n) + bf(n), per ogni n n 0. Esercizio 2.9. Dimostriamo che log a n è in Θ(log b n). Svolgimento: Poiché log b n = (log b a)(log a n), ponendo c = log b a abbiamo che c(log a n) log b n c(log a n) per ogni n 0. Esercizio Verificare che n(2 + sin n) = Θ(n). Svolgimento: Consideriamo le due disequazioni c 1 n n(2 + sin n) c 2 n. Abbiamo che n n(2 + sin n) e quindi basta scegliere c 1 = 1. Similmente n(2 + sin n) c 2 n sse 2 + sin n c 2. Scegliendo c 2 = 4 ciò è sempre vero. Esercizio Ordinare le seguenti classi di complessità: n 2, n log n, n 3 + log n, n, n 2 + 2n log n, log(log n), 17 log n, 10n 3 2, n 5 n 4 + 2n, 5n 2 log(log n), 3n 2 + n 3 log n, n + 6 log n. Svolgimento: Iniziamo confrontando n 5 n 4 +2n e 3n 2 +n 3 log n. Vogliamo dire che 3n 2 +n 3 log n o(n 5 n 4 n + 2n). Calcoliamo lim 5 n 4 +2n x 3n 2 +n 3 log n = lim x n2 n 3 = +. n +log n Poniamo y = log n. Allora log n n sse y 2 n sse y 2 2 y. Questa disuguaglianza è vera a partire dal valore y = 4 e dunque dal valore n 0 = 16 in poi. Quindi log(log n) log( n) 1 n = n 4. Pertanto esiste un n 0 tale che 5n 2 log(log n) 5n 9 4 O(n 3 + log n). Similmente possiamo ordinare tutte le altre funzioni. Alla fine ci risulta che 3n 2 + n 3 log n O(n 5 n 4 + 2n), n 3 + log n O(3n 2 + n 3 log n), 5n 2 log(log n) O(n 3 + log n), n 2 + 2n log n O(5n 2 log(log n)), n 2 O(n 2 + 2n log n), 10n 3 2 O(n 2 ), n log n O(10n 3 2 ), n + 6 log n O(n log n) n O(n + 6 log n), 17 log n O( n), log(log n) O(17 log n). Inoltre nessuna coppia di queste funzioni appartiene alla stessa Θ-classe di equivalenza. Esercizio Scrivere un algoritmo che prende in input una lista e calcola il numero dei massimi locali. Calcolarne quindi la complessità. Svolgimento: Ecco un possibile algoritmo. 24

25 9 input : array A di interi 10 output : il numero dei massimi locali in A c := 0; 13 j := 0; 14 while ( j< lentgh (A) ) { 15 if (j >0 and j+1 < length (A) and A[j -1] < A[j] > A[j +1]) { 16 c := c +1; 17 } 18 if (j >0 and j= length (A) -1 and A[j -1] < A[j]){ 19 c := c +1; 20 } 21 if (j -1=0 and j< length (A) and A[j -1] > A[j]){ 22 c := c +1; 23 } 24 j := j +1; 25 } 26 return c; La sua complessità è Θ(n) dove n è la lunghezza di A. Esercizio Risolvere le seguenti relazioni di ricorrenza utilizzando il master theorem: 1. T (n) = 2T ( n 4 ) + n T (n) = 3T ( n 3 ) + n 3. T (n) = 64T ( n 8 ) + n2 log n Svolgimento: Per i casi base (n = 1) le ricorrenze sono definite come Θ(1). 1. Siccome 0.51 = log 4 (2)+ε con ε > 0, abbiamo che n 0.51 = Ω(n log 4 (2)+ε ). Risolvendo la disequazione 2( n 4 )0.51 cn rispetto ad n otteniamo 4 c. Siccome < 1, possiamo scegliere per c 0.51 un valore nell intervallo ( 2 4, 1), che soddisfa la disequazione per ogni n 0. Quindi T (n) = 0.51 Θ(n log 4 (2) ). 2. Abbiamo che n O(n log 3 (3) ε ) e dunque T (n) = Θ(n log 3 (3) ). 3. Abbiamo che n 2 log n Ω(n log 8 (64)+ε ). Risolvendo la disequazione 64( n 8 )2 (log n 8 ) cn2 log n rispetto ad n otteniamo log n c. Al crescere di n l intervallo (0, 1 log n ) tende all intervallo (0, 1). Siccome c va scelto nell intervallo (1 3 log n, 1), non c è un valore di c che vada bene per tutti gli n a partire da un certo naturale in poi. Qui il master theorem non si può applicare. Esercizio Trovare i limiti asintotici superiori ed inferiori (migliori possibile) per T (n) in ciascuna delle seguenti ricorrenze (supponendo che T (n) = Θ(1) per n 2). 1. T (n) = 3T ( n 2 ) + n log n 2. T (n) = 5T ( n 5 ) + n log n 3. T (n) = 4T ( n 2 ) + n2 n 4. T (n) = 3T ( n 3 + 5) + n 2 5. T (n) = 2T ( n 2 ) + n log n 6. T (n) = T (n 1) + 1 n 7. T (n) = T (n 1) + log n 8. T (n) = T (n 2) + 2 log n 9. T (n) = nt ( n) + n 25

26 Svolgimento: (1) Siccome log 2 3 > 1 e n log n O(n log 2 3 ε ) per un certo ε > 0 (p.e. applicare il Master Theorem per concludere che T (n) Θ(n log 2 3 ). log ) basta n n (2) In questo caso log b a = log 5 5 = 1. Notiamo che log n Θ(n) perché n O( log n ). Per vedere ciò basta considerare la disequazione n cn log n, le cui soluzioni in n sono intervalli della forma (0, 2c ]. n Notiamo anche che log n O(n1 ε n ) perché la disequazione log n cn n ha come soluzioni i naturali n tali ε che nε log n c. Per ogni c > 0 fissato questa disequazione ha un insieme finito di soluzioni naturali. Infine n esiste un ε > 0 tale che log n Ω(n1+ε ) perché n log n cn 1+ε sse n log n cnn ε sse 1 n ε log n c 1 e per ogni c > 0 fissato esiste un n 0 > 0 tale che per ogni n n 0 abbiamo n ε log n c. Basta prendere ad esempio ε = 1 2. Ora vediamo che n 5 log n 5 sse log n 5 log n 5 log 5 c c n log n log x La funzione f(x) = 5 log x 5 log 5 è monotona decrescente per x 10 e quindi basta scegliere c = f(10) < 1. Pertanto il Master Theorem ci dice che T (n) Ω(n ε ). (3) In questo caso log b a = log 2 4 = 2. Inoltre n 2 n = n 5 2 Ω(n 2+ε ) (basta scegliere 0 < ε < 1 2 ). Ora vediamo che 4( n 2 ) 5 2 cn 5 2 sse 4 c Quindi possiamo applicare il Master Theorem e concludere che T (n) Θ(n 5 2 ) (4) Nella forma T (n) = 3T ( n 3 + 5) + n 2 non si può applicare il Master Theorem. Però possiamo effettuare un cambio di variabile y n + 15 e risolvere S(y) = 3T ( y 3 ) + y Siccome f(y) = y 15 2 Θ(y log 3 3 ) concludiamo che S(y) Θ(y log y). Infine T (n) = S(y 15) Θ((y 15) log(y 15)) = Θ(n log n). n (5) In questo caso log b a = 1. Non si possono applicare i casi del Master Theorem perché log n O(n1 ε ) n e log n Ω(n1+ε ). Allora useremo il metodo dell iterazione: Quindi T (n) O(n + n log 2 n). T (n) = 2 log 2 n + n log 2 n 1 j=0 = n + n log 2 n 1 j=0 = n + n log 2 n i=1 n + n log 2 n 1 i 1 log 2 1 log 2 n j (6) Non si possono applicare i casi del Master Theorem ma useremo il metodo dell iterazione: n 2 j Quindi T (n) O(n). T (n) = T (n 1) + 1 n = n 1 1 i=0 n i = n i=1 1 i n 26

27 (7) Non si possono applicare i casi del Master Theorem ma useremo il metodo dell iterazione: Quindi T (n) O(n). T (n) = T (n 1) + log n = n 1 1 i=0 = n i=1 n log(n i) 1 log i (8) Non si possono applicare i casi del Master Theorem ma useremo il metodo dell iterazione: Quindi T (n) O(n). T (n) = T (n 2) + 2 log n = n i=0 2 log(n 2i) n (9) Non si possono applicare i casi del Master Theorem ma useremo il metodo dell iterazione: T (n) = n + n 1 2 T (n 1 2 ) = n n (n n T (n 1 = d i=0 (n 1 2 i i j=0 n 1 = d i=0 (n 1 2 i n i 2 j ) j=0 ( 1 2 )j ) = d i=0 (n 1 2 i n i ) = d i=0 (n 1 2 i n 2 ) n 1 2 i = d i=0 n2 n 2 log 2 n dove d è il massimo numero naturale tale che n 1 2 d 1. Troviamo che T (n) O(n 2 log n). 2 2 )) 27

28 28

29 Chapter 3 Correttezza degli algoritmi 3.1 Algoritmi iterativi Per dimostrare la correttezza degli algoritmi iterativi si utilizza l invariante di ciclo, ossia una proposizione (riguardante i contenuti delle variabili della procedura o programma) che rispetta le seguenti proprietà: Inizializzazione: la proposizione è vera immediatamente prima di entrare nel ciclo. Mantenimento: se la proposizione è vera prima di eseguire un iterazione, lo è anche al termine dell iterazione. Terminazione: al termine del ciclo, la proposizione permette di ricavare la proprietà che permette di dimostrare la correttezza dell algoritmo. Esempio 3.1. Consideriamo l algoritmo fibonacciiterativomodificato, del quale vogliamo dimostrare il fatto che calcoli l n-esimo numero di Fibonacci; l invariante di ciclo è il seguente: Ad ogni iterazione, b = F i 1 e a = F i 2 Inizializzazione: poiché i = 3, dobbiamo verificare che b = F 2 e a = F 1 ; la dimostrazione è immediata, poiché b = 1 = F 2 e a = 1 = F 1. Mantenimento: assumiamo l invariante verificato per una generica i-esima iterazione e dimostriamo che esso vale anche al termine di tale iterazione; ricordiamo inoltre, nonostante non sia esplicitamente indicato, che al termine dell iterazione viene incrementato l indice i. Grazie alla nostra assunzione, abbiamo b = F i 1 e a = F i 2 : alla variabile c viene assegnato il valore della somma a + b = F i 2 + F i 1 = F i, alla variabile a viene assegnato il valore di b = F i 1, alla variabile b il valore di c = F i ed i viene incrementata (i = i + 1); è immediato dimostrare che continua a valere l invariante, ossia che b = F (i+1) 1 e a = F (i+1) 2. Terminazione: all uscita del ciclo, si ha i = n+1, dunque b = F (n+1) 1 = F n, che è il valore restituito, come volevasi dimostrare. 3.2 Algoritmi ricorsivi La dimostrazione viene svolta procedendo per induzione; occorre formalizzare una proprietà utile per dimostrare la correttezza dell algoritmo e provare che: valga per i casi base; assumendo che valga per problemi di dimensione inferiore, ossia per le chiamate ricorsive eseguite, provare che vale anche per il problema iniziale (passo induttivo). Esempio 3.2. Consideriamo l algoritmo fibonacciricorsivo e formalizziamo la seguente proprietà: L output della chiamata di funzione fibonacciricorsivo(n) è l n-esimo numero di Fibonacci. 29

30 Casi base: per n = 1 e n = 2, l algoritmo restituisce 1 = F 1 = F 2. Ipotesi induttiva: supponiamo che, per k < n, fibonacciricorsivo(k) restituisca F k. Passo induttivo: l algoritmo restituisce fibonacciricorsivo(n 1) + fibonacciricorsivo(n 2) (sia n > 2); per ipotesi, essi restituiscono, rispettivamente, F n 1 e F n 2, la cui somma è F n, come volevasi dimostrare. 30

31 Chapter 4 Pile e code 4.1 Pile La pila è una struttura dati, realizzabile sia con strutture indicizzate, sia collegate, che può essere descritta dal seguente schema generale: Dati: una sequenza S di n elementi. Operazioni: isempty() booleano Restituisce true se S è vuota, false altrimenti. push(elem e) void Aggiunge e come ultimo elemento di S. pop() elem Toglie da S l ultimo elemento e lo restituisce. top() elem Restituisce l ultimo elemento di S, senza rimuoverlo. 4.2 Code La coda, come la pila, è una struttura dati realizzabile sia mediante strutture indicizzate, sia con strutture collegate; la realizzazione di una coda segue il seguente schema generale: Dati: una sequenza S di n elementi. Operazioni: isempty() booleano Restituisce true se S è vuota, false altrimenti. enqueue(elem e) void Aggiunge e come ultimo elemento di S. dequeue() elem Toglie da S il primo elemento e lo restituisce. first() elem Restituisce il primo elemento di S, senza rimuoverlo. 4.3 Esercizi Esercizio 4.1. Realizzare una coda Q utilizzando due pile P 1 e P 2. 31

32 Svolgimento: Supponiamo di avere due pile P 1 e P 2. La pila P 1 ci serve per mantenere la collezione di oggetti, mentre P 2 serve come ausilio per le operazioni. Metodo enqueue dell oggetto Q. void enqueue(item x){ while(!p_1.isempty()){ P_2.push(P_1.pop()) } P_1.push(x) while(!p_2.isempty()){ P_1.push(P_2.pop()) } } Item dequeue(item x){ return P_1.pop() } boolean isempty(){ return P_1.isEmpty() } Esercizio 4.2. Realizzare una pila P utilizzando due code Q 1 e Q 2. Svolgimento: Supponiamo di avere due code Q 1 e Q 2. La pila Q 1 ci serve per mantenere la collezione di oggetti, mentre Q 2 serve come ausilio per le operazioni. void push(item x){ while(!q_1.isempty()){ Q_2.enqueue(Q_1.dequeue()) } Q_1.enqueue(x) while(!q_2.isempty()){ Q_1.enqueue(Q_2.dequeue()) } } Item pop(item x){ return Q_1.dequeue() } boolean isempty(){ return Q_1.isEmpty() } 32