4. Algoritmi Numerici Fondamentali

Transcript

1 4. Algoritmi Numerici Fondamentali Consideriamo adesso un algoritmo classico, per il calcolo del Massimo Comun Divisore (MCD) tra due numeri interi, n ed m: l'algoritmo di Euclide. Senza perdita di generalità, assumiamo n m > 0 e chiamiamo R il MCD. Possiamo descrivere l'algoritmo di Euclide in un linguaggio pseudo-naturale: Euclide(n,m) x n y m while x y do if x > y then x x - y else y y - x endif end R y All'algoritmo descritto sopra corrisponde il diagramma di flusso della Figura 16. Questo algoritmo ha un ciclo di natura diversa da quelli visti in precedenza, perchè non si sa quante volte il ciclo stesso venga eseguito. Consideriamo il ciclo dell'algoritmo e scriviamolo esplicitando un contatore k del numero di cicli eseguiti: 32 k x k-1, y k-1 x k, y k Otteniamo le seguenti condizioni: Asserzione iniziale: n m > 0 Condizione iniziale: x 0 = n, y 0 = m Condizione di terminazione: x t = y t per qualche t Invariante: MCD(x k, y k ) = MCD(n,m) Asserzione finale: R = MCD(x t, y t ) = MCD(n,m) In questo caso, non si sa a priori quante volte venga eseguito il ciclo, perchè non si sa quando la condizione che lo controlla diventi vera. Nella Tabella A riportiamo l'esecuzione dell'algoritmo per n = 40 ed m = 16. Tabella A k x y 0 (n =) 40 (m = ) La correttezza dell'algoritmo è dovuta alla seguente proprietà del MCD: Supponendo, senza restrizione, che n m, se R = MCD(n,m), allora:

2 33 (a) n = h 1 R, m = h 2 R (b) Non esiste un numero R' > R tale che per esso valgano le (a). n, m n m > 0 x <- n y <- m MCD(n,m) = MCD(x,y) x = y x y x = y x MCD(n,m) = n x < y x > y x > y y <- (y-x) x <- (x-y) y - x > 0 x - y > 0 Figura 16 Algoritmo di Euclide basato sulle differenze successive Consideriamo la differenza n - m = R (h 1 - h 2 ). Il numero (h 1 - h 2 ) è un numero intero e quindi R è anche un divisore della differenza (n - m). Inoltre, non esisterà un numero R' > R che goda dlla stessa proprietà, perchè non esiste né per n né per m. Quindi, il MCD di due numeri è anche il MCD di uno qualsiasi dei due e della loro differenza. L'Algoritmo di Euclide calcola il MCD tra due numeri riducendo iterativamente il calcolo a quello del MCD tra il minore dei due e la loro differenza. Consideriamo adesso la terminazione e la complessità dell'algoritmo. Abbiamo che: x 0 = n, y 0 = m Il ciclo viene ripetuto fino a che si raggiunge un t tale per cui x t = y t. Quindi, finchè è k < t, abbiamo: x k = if (x k-1 > y k-1 ) then (x k-1 - y k-1 ) else x k-1 y k = if (x k-1 < y k-1 ) then (y k-1 - x k-1 ) else y k-1 (9) Le (9) implicano che, ad ogni iterazione, la maggiore tra le due variabili y k e x k diminuisce. Quindi, essendo y k e x k sempre > 0, la loro differenza tende

3 34 necessariamente a 0, implicando l'esistenza di un t per cui x t = y t. Quindi il programma termina. Il ciclo viene quindi eseguito t volte e la complessità dell'algoritmo è data da: C(n, m) = t = 4 (t + 1) = O(t) Quando m = 1, il ciclo di sottrazioni successive viene fatto tante volte quante sono le unità di n, perché ad ogni ciclo viene tolta 1 unità da x. Quindi, t n: C(n, m) = O(Max(n, m)) (10) L'Algoritmo di Euclide può essere modificato in modo da avere una complessità minore di quella lineare data dalla (10). Occorre introdurre l'operazione binaria mod : n mod m = Resto della divisione intera tra n e m (11) Per esempio, (12 mod 5) = 2, (23 mod 10) = 3. Osservando che il resto della divisione è il numero che rimane dopo aver tolto il divisore dal dividendo un numero di volte pari al quoziente intero, il ciclo dell'algoritmo di Euclide può essere trasformato sostituendo il mod alla sottrazione; di nuovo, senza restrizione, si può pensare che n m > 0. Euclide(n,m) while m 0 do z n n m m n mod m end R n Analizzando l'algoritmo in modo analogo al precedente, abbiamo: n k-1, m k-1 Asserzione iniziale: n m > 0 Condizione iniziale: n 0 = n, m 0 = m k Condizione di terminazione: m t = 0 Invariante: MCD(n k, m k ) = MCD(n,m) n k, m k Asserzione finale: R = MCD(n,m) Durante il ciclo, abbiamo le seguenti assegnazioni: n k = m k-1 m k = n k-1 mod m k-1 = m k-2 mod m k-1 (12) Usiamo adesso il seguente lemma: Lemma 1 Per ogni coppia di numeri interi (x, y), si ha: x mod y < x/2. Dimostrazione : Sappiamo che, per definizione, è x mod y < y. Consideriamo adesso due casi: (a) Se y x/2, allora, per la proprietà transitiva: x mod y < y x/2 e il lemma è vero. (b) Se x/2 < y < x, allora il quoziente di n/m sarà uguale a 1 e il resto non è altro che la differenza (x - y). Ma, se y > x/2, sarà (x - y) = x mod y < x/2. Quindi, in ogni caso possibile il lemma è vero. Usando il risultato del Lemma 1, dalla (12) abbiamo che: m k = n k-1 mod m k-1 = m k-2 mod m k-1 < m k-2 /2 (13) La (13) ci dice che il valore di m si dimezza (almeno) ogni due passi. Quindi, quando m 2t vale 1, si ha al più un ciclo solo da eseguire ancora. Otteniamo: k = 0 : m 0 = m, k = 2 : m 2 < m/2 1, k = 4 : m 4 < m/2 2,, k = 2 t : m 2t < m/2 t

4 35 La condizione di trminazione dice che deve essere: m/2 t = 1 2 t = m t = lg 2 m Quindi, la complessità dell'algoritmo di Euclide modificato è data da: C(n, m) = O(lg 2 min(n, m)) (14) La terminazione e la correttezza si dimostrano allo stesso modo che per l'algoritmo basato sulle differenze successive. Analizziamo ora un altro algoritmo classico, denominato Setacci di Eratostene, che genera tutti i numeri primi in sequenza crescente. L'algoritmo associa ad ogni numero primo p j (j 1) un "setaccio" σ j, attraverso le cui maglie "cadono" i numeri che sono multipli di p j : p 1 = 2 p 2 = 3 p 3 = 5 p j. p k Viene esaminata la sequenza dei numeri interi dispari (quelli pari non sono primi) e dalla sequenza vengono eliminati tutti i numeri che non sono primi. L'idea dell'algoritmo è quella di far passare i numeri sopra tutti i setacci generati fino a quel momento; se il numero non cade in alcuno dei setacci, allora è il prossimo primo. Nella Figura 17 è riportato il diagramma di flusso. p 1 = 2, p 2 = 3, k = 2 n = 3 p 1 Sqrt(3) p j Sqrt(n) primo(n) j = 1 p k Sqrt(n) primo(n) j = j + 1 p j Sqrt(n) and (n mod p j 0) n = n + 2 primo(n ) p j > Sqrt(n) primo(n) k = k + 1 p k = n n mod p j 0 p k = n primo(n) Figura 17 Algoritmo dei Setacci di Eratostene, per la generazione dei numeri primi.

5 36 L'algoritmo presenta due cicli annidati, il più esterno dei quali non termina, perchè deve trovare tutti i primi. Quello più interno, invece, deve terminare per ogni valore di n. Nell'algoritmo, k denota il numero di primi già trovati al momento in cui si esamina n. Quindi, i primi presenti saranno quelli da p 1 a p k. Osserviamo che il ciclo interno si può fermare per due motivi: (a) Il numero n cade in un setaccio ( n è multiplo di un p j ) (b) Si sono esaminati tutti i primi utili. Questi primi sono quelli che vanno da p 1 a un primo p t tale che p t [ ], ma p t+1 > [ ]. In altre parole basta esaminare quei primi che non superano. La ragione di questo risiede nel fatto che il numero n, se non è primo, cade nel setaccio che corrisponde al più piccolo dei suoi divisori. Sia p il più piccolo divisore di n; allora esisterà un altro intero divisore r, tale che, per definizione di divisibilità, soddisfa la relazione: n = p r (15) Ma p è il più piccolo divisore di n, quindi: r p. Sostituendo nella (15), otteniamo: n = p r p p = p 2 -> p Essendo p intero, sarà alla fine: p [ ]. Consideriamo lo schema dei due cicli, per calcolare gli invarianti. n i-1, k i-1 i j 2 p i-1 p j n i, k i Ciclo esterno n 0 = 3, k 0 = 1 Il ciclo non termina n i = n k i = if (n i-1 è primo) then (k i-1 + 1) else k i-1 Ciclo interno p 1 = 2, k 1 = 1 Il ciclo termina per un t tale che p t [ ] e p t+1 > [ ] p j = next-prime(p j-1 ) Terminazione del ciclo interno Siccome ad ogni iterazione p j aumenta, perchè la sequenza dei primi è strettamente crescente, e siccome n 1-1 è costante nel ciclo, esiste sicuramente un numero t tale che la condizione di terminazione diventa vera. Correttezza Dobbiamo dimostrare che l'algoritmo trova tutti e soli i primi esistenti. Osserviamo subito che l'algoritmo non può perdere un numero primo. Infatti, sia p il numero primo perso: in questo caso, p deve essere stato trovato non primo e quindi eliminato dalla sequenza dei numeri dispari, essendo caduto in un setaccio. Questo è impossibile, perchè, non esistendo alcun divisore di p, p non può cadere in alcun setaccio. D'altra parte, potrebbe accadere che un numero n non primo sia dichiarato primo. Questo errore potrebbe verificarsi se, al momento di esaminare n, non fossero stati trovati tutti i setacci occorrenti, e cioè se p k < p t [ ]. Facciamo vedere che questo non è possibile usando il principio di induzione (Ricordiamo che p k è l'ultimo primo trovato).

6 37 Passo base: B 0 -> Quando si esamina n 0 = 3, è k = 1, p 1 = 2 > Ipotesi induttiva: Hp : Per tutti i valori dell'indice del ciclo fino a (i-1), vale la relazione p k(i-1)+1 > [ ], essendo p k(i-1) l'ultimo primo trovato quando si esamina n i-1. Tesi da dimostrare: Ts : Si ha p k(i)+1 > [ ]. Si ha la relazione n i = n i Quindi, [ ] [ ] + 1. D'altra parte, per quanto riguarda i primi trovati, essi non cambiano se n i-1 non è primo. In questo caso, sarà ancora p k(i)+1 = p k(i-1)+1 [ ], perchè n i non può richiedere un ulteriore primo per la sua analisi, non essendoci due primi che differiscono di meno di due unità (tranne che per 2 e 3, caso che viene esaminato direttamente). Se n i-1 è primo, si ha k(i) = k(i-1) e quindi p k(i)+1 p k(i-1) [ ]. Quindi, l'algoritmo è corretto. Complessità Per quanto riguarda la complessità, consideriamo la Figura 16. L'algoritmo ha una complessità sostanzialmente dipendente dai due cicli annidati. Dato che il ciclo esterno non si ferma, per valutare la complessità, assumiamo che si vogliano trovare i primi non superiori a un numero N (dispari). Quindi, il ciclo esterno è ripetuto (N-1)/2 volte. Per ogni ripetizione, cui è associato il valore n, si fanno un massimo di t confronti tra n e i setacci, con p t+1 > [ ]. Questi confronti si fanno tutti quando n è primo, ma se ne possono fare di meno quando n non è primo. Siccome cerchiamo la massima complessità (quella del caso peggiore), possiamo dire che vengono fatti sempre t(n) confronti. Ma t(n) è il numero di primi non superiori a [ ]. Siccome vale la relazione: avremo che: (Numero di primi M) ~ per ogni M (16) t(n) ~ La complessità sarà dunque: C(N) = = O(N 3/2 /lnn) Nell'Esempio 25 avevamo introdotto un algoritmo per il calcolo della potenza y = x n, che era lineare con n. Vogliamo adesso vedere se c'è un algoritmo più efficiente di quello. Se la potenza n = 2p e un numero pari, possiamo scrivere: x n = x 2p = x p * x p (17) Per calcolare x n occorre fare n = 2p moltiplicazioni, ma usando la (17) e memorizzando x p, basta farne (p + 1 ). Se p è ancora un numero pari, possiamo ripetere il procedimento. Quindi se n è una potenza di 2, cioè n = 2 m posso scrivere l'algoritmo di Figura 18. Analizziamo l'algoritmo. Sia k la variabile che denota il numero di ripetizioni del ciclo. Avremo: Asserzione inziale: base 0 = x, esp 0 = n Asserzione finale: esp t = 1 per un certo t base k = base k-1 * base k-1 ; esp k = esp k-1 /2

7 38 x, n (x 0) (n = 2 m ) (m 0) esp = n base = x (x n = base esp ) (esp = 2 q ) (q 0) esp = 1 base (esp = 2 q ) (q > 0) base = base * base (x n = base esp/2 ) esp = esp/2 Figura 18 Calcolo della potenza x n. Avremo quindi: base 0 = x esp 0 = n base 1 = base 0 * base 0 = x 2 esp 1 = esp 0 / 2 = n/2 base 2 = base 1 * base 1 = (x 2 ) 2 = x 4 esp 2 = esp 1 / 2 = n/4.. base k = base k-1 * base k-1 = (x 2 ) 2 = x 2k esp k = esp k-1 / 2 = n/2 k Quando ci si ferma, si deve avere: esp t = n/2 t = 1 t = lg 2 n Quindi, il programma termina, perchè esp diminuisce ad ogni ciclo, pur restando positivo. Quando k = t = lg 2 n, il programma fornisce l'output: base t = x 2t = x 2 lg2n = x n Quindi l'algoritmo è corretto. Per quanto riguarda la complessità, essa dipende dal numero di volte che il ciclo viene eseguito: C (n) = O(t) = O(lg 2 n). Qundo n non è una potenza di 2, in particolare se n è dispari, si può scrivere n = 2p +1 e possiamo scrivere x n = x (2p+1) = x * x (2p) e quindi applicare il procedimento visto per gli n pari al passo successivo, ottenendo l'algoritmo di Figura 19. Analizziamo il ciclo e dimostriamo che la formula x n = (ris base esp ) (esp 0) è l invariante. base k-1, esp k-1, ris k-1 Condizione iniziale: base 0 = x, esp 0 = n, ris 0 = 1 Condizione finale: esp t = 0 per un certo t k base k-1, esp k-1, ris k-1

8 39 Inoltre: base k = if (esp k-1 è pari) then( base k-1 ) 2 else base k-1 esp k = if (esp k-1 è pari) then esp k-1 /2 else esp k-1 ris k = if (esp k-1 è pari) then ris k-1 else ris k-1 * base k-1 La prima volta che si entra nel ciclo, e cioè quando ris = 1, esp = n e base = x, l invariante è certamente vero. Supponiamo che lo sia dopo un certo numero di iterazioni e dimostriamo che lo è dopo una ulteriore iterazione, usando il principio di induzione matematica. Da esp 0 ed esp 0 deriviamo esp > 0. Nel caso in cui esp sia pari : ris (base esp = ris) (base base esp/2 ) (18) Dopo l assegnamento base base*base è vera l asserzione: (x n = ris) base esp/2 e quindi dopo l'assegnazione esp esp/2 ritrovo l invariante. Notiamo che nel caso in cui esp sia dispari, l equazione (18) non è vera. In questo caso sappiamo che: ris (base esp = ris) base base esp-1 Quindi, dopo l assegnamento ris ris * base ottengo l asserzione: (x n = ris) base esp-1 e dopo l assegnamento esp esp-1 ottengo di nuovo l'invariante. Inoltre, poichè n 0, il programma termina. Quindi all uscita del ciclo (cioè quando esp = 0) l invariante diventa: (x n = ris) (base 0 = ris) (1 = ris) che è esattamente l asserzione finale. Calcoliamo ora la complessità dell algoritmo. La complessità è dell ordine del numero dei cicli effettuati. Per prima cosa vediamo un esempio. Si consideri x 13. Con l algoritmo lineare si effettuano 13 cicli, mentre con questo algoritmo si effettuano cicli con esp = 13, esp = 12, esp = 6, esp = 3, esp = 2, esp = 1 (poi esp = 0 e si esce). Quindi si effettuano 6 cicli. Consideriamo l algoritmo in generale. Abbiamo visto che il caso migliore si ha quando l esponente n è una potenza di 2, diciamo 2 m. In questo caso si effettuano m cicli, e cioè un numero di cicli pari a log 2 n. Il caso peggiore si ha quando n è dispari, e tutte le volte che si sottrae 1 o si divide per 2 il numero risultante è ancora dispari. In questo caso n = 2 m - 1, per cui effettueremo (2 log 2 n) volte il ciclo. Quindi la complessità è O(log 2 n).