Dispense sulla Complessità Computazionale

Transcript

1 Dispese sulla Complessità Computazioale Complessità Computazioale... Premessa... La misura dell efficieza... Ordie di gradezza delle fuzioi... 2 Notazioi asitotiche... 2 Tre otazioi: motivazioi e defiizioi... 2 O(g())... 3 Ω(g())... 3 Θ(g())... 3 Implicazioi... 4 Uso improprio... 4 Alcue cosiderazioi... 4 Calcolo della complessità computazioale dei pricipali costrutti di programmazioe... 5 Istruzioi... 5 Blocchi... 5 Costrutti selettivi... 5 Cicli... 6 Ciclo While... 6 Ciclo For... 6 Chiamate di fuzioi... 6 Calcolo della complessità di fuzioi ricorsive... 6 Formule di ricorreza: Metodi di soluzioe... 7 Esempi... 8 Calcolo del fattoriale... 8 La Torre di Haoi... 8 MergeSort... 9 QuickSort...

2 Complessità Computazioale Premessa U aspetto importate che o può essere trascurato ella progettazioe di u algoritmo è la caratterizzazioe dell efficieza co la quale l algoritmo stesso viee eseguito su u elaboratore. L efficieza è, tra l altro, da itedersi o solo come tempo di esecuzioe, ma ache i fuzioe dell utilizzo delle altre risorse del sistema di elaborazioe, come, ad esempio, la memoria cetrale. I questo capitolo viee itrodotto u modello per la misura dell efficieza di u programma. Il modello permette di caratterizzare l efficieza di esecuzioe (complessità computazioale o temporale) e l efficieza i termii di memoria impiegata (complessità spaziale) i maiera idipedete dal sistema di elaborazioe sul quale si itede eseguire il programma i oggetto. La misura dell efficieza L efficieza di u algoritmo (e da ora i poi, se o esplicitamete idicato, parleremo idistitamete di efficieza spaziale o di efficieza computazioale) o può essere misurata semplicemete, i quato dipedete da u umero elevatissimo di fattori. Dato u programma scritto i liguaggio sorgete l efficieza dell esecuzioe dipede dal compilatore impiegato che effettua ua traduzioe i codice macchia che può essere più o meo efficiete, dalla struttura del sistema di elaborazioe che può risultare più adeguata ad eseguire rapidamete alcue classi di istruzioi, dalla poteza della CPU del sistema di elaborazioe, e via di seguito. E quidi importate otare esplicitamete che il tetativo di caratterizzare l efficieza o può che prescidere dalla architettura di sistema di elaborazioe adottato, e cocetrarsi sugli aspetti che ivece soo strettamete legati alla atura e struttura dell algoritmo prescelto. Nel seguito di questo paragrafo teteremo di defiire i che ottica avviee la caratterizzazioe dell efficieza e ei paragrafi segueti daremo degli strumeti operativi per valutare l efficieza di u geerico algoritmo cosiderato. Suppoiamo di cosiderare u algoritmo A e di voler caratterizzare la sua complessità computazioale. Allora, se idichiamo co T il tempo impiegato dall algoritmo, ed la dimesioe della struttura dati d su cui opera A, oi siamo iteressati a caratterizzare la fuzioe: T=T(). A titolo di esempio se A è u programma che realizza l ordiameto di u vettore, è chiaro che è il riempimeto del vettore che iflueza, come oto, il tempo di esecuzioe di A. Spesso u algoritmo ha u tempo di esecuzioe che dipede dalla dimesioe di più strutture dati. Si pesi ad u programma che realizza la fusioe di due vettori ordiati; i questo caso è evidete che la fuzioe T dipede sia dalla lughezza del primo vettore che dalla lughezza del secodo e quidi è ua fuzioe di più variabili. Nel corso del capitolo correte il umero di variabili da cui dipede T o iflueza i risultati e le cosiderazioi che tracceremo e, di cosegueza, per motivi di semplicità faremo riferimeto ad ua fuzioe T di ua sola variabile. Visto che è ecessario prescidere dal particolare compilatore o dalla architettura del calcolatore su cui verrà eseguito l algoritmo, il modello che si assumerà per il calcolo del tempo T() è il modello computazioale tipicamete idicato co radom-access machie (RAM). Nel modello RAM si cosidera u geerico moo-processore i cui tutte le istruzioi soo eseguite ua dopo l altra, seza essu tipo di parallelismo. Ioltre si assumerà che le istruzioi semplici del liguaggio (istruzioi di assegameto, istruzioi co operatori aritmetici, relazioali o logici) abbiao u costo uitario i termii di tempo impiegato per la loro esecuzioe. Su questa base si procederà al calcolo del tempo complessivo T impiegato da tutte le istruzioi dall algoritmo, teedo coto ovviamete del fatto che tale tempo dovrà dipedere dalla dimesioe dei dati, visto che siamo iteressati alla valutazioe di T(). U altra cosiderazioe importate che è qui opportuo fare, è che il tempo T() potrebbe variare sesibilmete i dipedeza dello specifico valore assuto dalla struttura dati i igresso. Data ultimo aggiorameto 26/02/ Pag.

3 Quello che si vuol dire è che T oltre a dipedere dalla dimesioe della struttura dati d, potrebbe dipedere ache dagli valori assuti da ua geerica occorreza di d. Sempre rifacedoci al caso di u algoritmo A che deve effettuare l ordiameto di u vettore, potrebbe capitare che A impieghi u tempo sesibilmete diverso se il vettore i igresso e già ordiato rispetto al caso i cui tale vettore sia o ordiato (o magari addirittura cotrordiato). Per questo motivo l aalisi che si coduce per il calcolo del tempo T() va fatta esamiado tre casi possibili: il caso migliore, che corrispode a quelle (o a quella) cofigurazioi della struttura dati d che dao luogo ad u miimo della fuzioe T(), il caso peggiore che corrispode a quelle (o a quella) cofigurazioi della struttura dati d che corrispodoo ad u massimo della fuzioe T(), ed il caso medio, che evidetemete corrispode al comportameto medio della fuzioe al variare della cofigurazioe di d. Dovrebbe risultare chiaro, ma coviee comuque precisarlo, che l algoritmo cosiderato potrà ache avere u tempo di esecuzioe T() idipedete dai valori assuti da d. I tal caso il tempo impiegato el caso migliore sarà uguale a quello impiegato el caso peggiore, e quidi ache a quello impiegato el caso medio. Nel corso dei prossimi paragrafi, si aalizzerà dapprima come è possibile caratterizzare co delle opportue otazioi il tempo di calcolo di u algoritmo A al crescere della dimesioe della struttura dati su cui A opera e si illustrerà il perché di questo tipo di aalisi. I seguito si vedrà come è possibile utilizzare tali otazioi per caratterizzare la complessità computazioale dei pricipali costrutti di programmazioe, ivi comprese le chiamate di fuzioi. Ifie verrà affrotato il problema di calcolare il tempo di esecuzioe di fuzioi ricorsive: sarao itrodotte delle opportue formule, dette formule di ricorreza, e metodi per la loro soluzioe. Ordie di gradezza delle fuzioi Notazioi asitotiche Nello studio della complessità di u algoritmo l iteresse è spesso quello di verificare il comportameto dell algoritmo, i termii di tempo di calcolo, seza far riferimeto ad ua prefissata dimesioe dei dati di igresso. I particolare, visto che l icideza sul tempo di calcolo cresce al crescere di, l aalisi che si coduce è u aalisi al limite, ovvero si studia il comportameto dell algoritmo per u sufficietemete grade. Le otazioi che si itroducoo soo pertato dette otazioi asitotiche, i quato devoo caratterizzare il comportameto di u dato algoritmo a partire da u valore di sufficietemete grade. U altro cocetto da teer presete ella valutazioe del comportameto di u algoritmo è il seguete: affermare che u algoritmo ha u certo adameto asitotico, sigifica dire che per qualuque cofigurazioe di dati i igresso il comportameto asitotico è di quel tipo; i altri termii o è corretto valutare il comportameto asitotico solo el caso migliore (o i quello peggiore), ma è ecessario verificare l adameto dell algoritmo i tutti i casi possibili. Soo tuttavia corrette affermazioi del tipo: l algoritmo A ha u comportameto asitotico, el caso migliore, di tipo T, ache se tale comportameto è diverso el caso medio ed i quello peggiore. Tre otazioi: motivazioi e defiizioi Nelle defiizioi delle otazioi asitotiche ritroviamo formalizzato il cocetto di aalisi al limite: per dire che ua fuzioe f() appartiee ad u certo isieme X(g()) è ecessario che l adameto relativo di f() e g() sia di u certo tipo a partire da ua prefissata dimesioe del dato di igresso, ovvero per ogi maggiore di u certo 0. I particolare, i iformatica, soo tre le otazioi comuemete adottate: O, Ω, Θ. Ua delle ragioe per cui vegoo adottate tre otazioi è che le prime due, come sarà evideziato el seguito, foriscoo u limite lasco, rispettivamete per i limiti superiore ed iferiore, metre la Data ultimo aggiorameto 26/02/ Pag. 2

4 terza forisce u limite stretto. I alcui cotesti è difficile trovare u limite stretto per l adameto delle fuzioi, per cui ci si accoteta di u limite meo preciso. Tali otazioi furoo itrodotte i u classico articolo di Kuth del 76; tuttavia i molti testi viee riportata ua sola di queste otazioi, che i geere è la O. Tale scelta è dettata da ragioi di semplicità, sia per o itrodurre troppe otazioi (cosa che potrebbe cofodere le idee al lettore), sia perché i geere ciò che serve è ua limitazioe superiore del tempo impiegato da u dato algoritmo e, i quest ottica, dimostrare che u algoritmo appartiee alla classe O è, come detto, più semplice che dimostrare l apparteeza alla classe Θ. Vi è ioltre u ultimo puto che vale la pea rimarcare: ua otazioe asitotica deve, ove possibile essere semplice, tat è che, come vedremo, l utilizzo di tali otazioi ci cosete di trascurare costati moltiplicative e termii di ordie iferiore. Orbee, spesso, voledo trovare u limite stretto, è ecessario ricorrere a fuzioi più complesse di quelle che si potrebbero adottare se ci si limitasse a cosiderare u limite lasco. Più i geerale, se si vuole caratterizzare u algoritmo co u limite stretto può essere ecessario dover cosiderare separatamete il caso migliore e quello peggiore, metre se ci limita a cercare u limite superiore basta trovarlo per il solo caso peggiore ed evidetemete tale limite sarà valido per l algoritmo stesso; quest ultima cosiderazioe può essere u ulteriore giustifica all adozioe i alcui testi di ua sola otazioe, la O. Passiamo ora ad itrodurre le defiizioi delle tre otazioi asitotiche. O(g()) Date due costati positive c ed 0, ua fuzioe f() appartiee all isieme O(g()), ovvero f() O(g()) se: c, 0 > 0 > 0, 0 f() c g() ciò sigifica che, a partire da ua certa dimesioe 0 del dato di igresso, la fuzioe g() maggiora la fuzioe f(). Possiamo quidi ache dire che la g() rappreseta u limite superiore per la f(). Tale limite o è però stretto. Suppoiamo ifatti di avere ua fuzioe f() O( 2 ). Ciò implica che la f(), da u certo puto i poi, è maggiorata da 2 : se ciò è vero, ache 3 maggiorerà la f(), e quidi f() appartiee ache a O( 3 ). E evidete che quest ultima apparteeza implica u limite sicuramete meo stretto del precedete, ma rimae comuque formalmete ieccepibile. I geerale quado si itroduce la otazioe O (soprattutto i quei cotesti i cui è l uica otazioe presetata) si cerca comuque di idividuare u limite superiore il più possibile stretto, fermo restado che tale limite potrebbe essere raffiato ulteriormete. Si oti ioltre che il comportameto per tutti gli < 0 o è assolutamete teuto i coto, per cui potrao esserci dei valori di < 0 tali che f() > g(), come evideziato ache i Fig. b. Ω(g()) Date due costati positive c ed 0, ua fuzioe f() appartiee all isieme Ω(g()), ovvero f() Ω(g()) se: c, 0 > 0 > 0, f() c g() 0 ovvero, a partire da ua certa dimesioe 0 del dato di igresso, la fuzioe g() è maggiorata dalla fuzioe f(). Ache i questo caso il limite o è stretto, e valgoo sostazialmete tutte le cosiderazioi fatte per la otazioe O() (cfr. ache Fig. c). Θ(g()) Date tre costati positive c, c 2 ed 0, ua fuzioe f() appartiee all isieme Θ(g()), ovvero f() Θ(g()) se: c, c 2, 0 > 0 > 0, 0 c g() f() c 2 g() ovvero a partire da ua certa dimesioe 0 del dato di igresso, la fuzioe f() è compresa tra c g() e c 2 g(). I maiera iformale si può dire che, al crescere di, la f() e la g() crescoo allo stesso modo (vedi Fig. a). A differeza delle otazioi precedeti, duque, se ua fuzioe appartiee ad esempio a Θ( 2 ), o potrà apparteere ache a Θ(), é tatomeo a Θ( 3 ) Data ultimo aggiorameto 26/02/ Pag. 3

5 Fig. : Esempi di fuzioi f() che appartegoo rispettivamete agli isiemi (a) Θ(g()), (b) O(g()) e (c) Ω(g()). Si oti come le relazioi di diseguagliaza che compaioo elle defiizioi soo soddisfatte solo a partire da u certo valore 0 della dimesioe del dato di igresso. Implicazioi Dalle defiizioi suvviste discede il seguete teorema (che o dimostreremo): Date due fuzioi f() e g(), ua fuzioe f() Θ(g()) se e solo se f() O(g()) e f() Ω(g()). Uso improprio Come detto l utilizzo corretto delle otazioi asitotiche è i espressioi del tipo f() O(g()). E tuttavia prassi comue ammettere usi del tipo f() = O( 2 ). Ioltre i alcui casi è molto utile dal puto di vista otazioale, ache se formalmete scorretto, poter sommare due otazioi asitotiche, cioè ammettere espressioi del tipo T() = Θ ( 2 )+ Θ(). Quest ultima espressioe deve evidetemete itedersi come: T() è uguale alla somma di ua qualuque fuzioe che appartiee all isieme Θ ( 2 ) più ua qualuque fuzioe che appartiee all isieme Θ (). Alcue cosiderazioi Come detto all iizio del capitolo, o è corretto cosiderare solo il caso migliore per valutare il comportameto asitotico di u algoritmo. Solo i virtù del fatto che, ad es., il BubbleSort el caso migliore ha ua complessità lieare o basta per affermare che l algoritmo BubbleSort appartega a Θ() oppure a O(). Per lo stesso motivo o è corretto eppure affermare che il BubbleSort appartiee a Θ( 2 ) solo perché el caso peggiore la complessità è quadratica. Viceversa è corretto affermare che, el caso migliore, la complessità del BubbleSort è Θ(), che el caso medio e el caso peggiore la complessità è Θ( 2 ) e, più i geerale che il BubbleSort è O( 2 ) ovvero è Ω(). Altre due importati cosiderazioi fao riferimeto a casi i cui o soo verificate le codizioi che soo alla base dell itroduzioe delle otazioi asitotiche. Ifatti, proprio perché le otazioi itrodotte soo asitotiche, vegoo trascurati i termii di ordie iferiore e le costati moltiplicative. Tuttavia, el caso i cui è ecessario cofrotare algoritmi cui aveti tempi di esecuzioe T() il cui adameto al limite è uguale (es. soo etrambe O( 2 )), o è più possibile trascurare tali termii. I tal caso per stabilire quale algoritmo è più coveiete usare bisoga ecessariamete teer coto, i primo luogo delle costati moltiplicative, i primo luogo, e poi dei termii di ordie iferiore. U esempio classico è dato dalla scelta degli algoritmi di ordiameto: come dimostreremo el seguito il MergeSort è u algoritmo che appartiee a Θ(log), ovvero la sua complessità è sia el caso migliore che i quello peggiore (e quidi ache i quello medio) Θ(log). Il QuickSort, Data ultimo aggiorameto 26/02/ Pag. 4

6 viceversa è u algoritmo O( 2 ), la cui complessità el caso migliore e el caso medio è però Θ(log). Cotrariamete a quato si potrebbe pesare, l algoritmo di ordiameto più comuemete usato, e che si trova ormalmete implemetato elle librerie, è proprio quest ultimo. Questa scelta ha origie da due ordii di cosiderazioi: la prima è di carattere tecico, dovuta al fatto che il QuickSort svolge l ordiameto sul posto, e che quidi ha miore complessità spaziale del MergeSort, la secoda, ivece, è dovuta proprio al fatto che, da u lato la probabilità che per il QuickSort si verifichi il caso pessimo è abbastaza remota (e quidi cosiderare ache il QuickSort come u algoritmo di complessità Θ(log), pur o essedo formalmete corretto, è ua assuzioe abbastaza prossima alla realtà) dall altro che le costati moltiplicative el caso del QuickSort soo miori rispetto a quelle del MergeSort. Quidi per scegliere tra due algoritmi che hao sostazialmete lo stesso ordie di complessità è ecessario cosiderare il peso delle costati moltiplicative e queste giocao a favore del QuickSort. U altro caso i cui o è corretto trascurare i termii ascosti dalla otazioe asitotica è il caso i cui siamo iteressati a cofrotare il comportameto di due algoritmi per u prefissato. I tal caso è possibile, ad esempio, che u algoritmo A di complessità Θ( 3 ) si comporti meglio di u algoritmo A 2 Θ( 2 ); per covicersee suppoiamo di aver fissato = 50 e che l algoritmo A abbia u tempo T() dato da 3 / 0 metre l algoritmo A 2 abbia T() uguale a I tal caso per A avremo T(50) = 2500, metre per A 2 avremo T(50) = 250. Calcolo della complessità computazioale dei pricipali costrutti di programmazioe Nel seguito daremo delle semplici regole per caratterizzare la complessità dei vari costrutti di programmazioe, sulla base delle otazioi asitotiche itrodotte ei precedeti paragrafi. Combiado opportuamete tali regole è possibile calcolare la complessità computazioale di u geerico algoritmo. Istruzioi Ua volta fissato il modello di costo della macchia RAM, le istruzioi di assegameto, le istruzioi che coivolgoo solo operatori aritmetici, relazioali o logici hao tutte, come detto, lo stesso costo computazioale. I particolare si assume che tali istruzioi abbiao complessità costate, per idicare la quale viee covezioalmete utilizzata la otazioe Θ () (o equivaletemete O()). Blocchi La complessità di u blocco sequeziale di istruzioi è data dalla complessità massima fra quelle delle istruzioi costitueti il blocco i questioe. Dette I,,I i,,i m le m istruzioi del blocco e f (),,f i (),,f m (), le fuzioi che e caratterizzao la complessità, la complessità del blocco sarà quidi data da: Θ (max i (f i ())). I questo caso si applica la cosiddetta regola della somma: cioè è possibile calcolare la complessità di ua sequeza di istruzioi come la somma delle complessità delle istruzioi compoeti e la complessità risultate è quella del termie di grado più alto. Se ad esempio ho u blocco di tre istruzioi, la cui complessità è rispettivamete Θ (), Θ () e Θ (), posso calcolare la complessità del blocco (idicadola co Θ blocco ) come: Θ blocco = Θ () + Θ () + Θ (), che per la regola della somma sarà uguale a Θ (). Costrutti selettivi La complessità di u istruzioe del tipo if <codizioe> the <istruzioi ramo the> else <istruzioi ramo else> è limitata superiormete dal ramo che ha la complessità maggiore. I realtà bisoga ache cosiderare il tempo impiegato a verificare la codizioe, che i geere ha Data ultimo aggiorameto 26/02/ Pag. 5

7 complessità costate. Idicado per semplicità co f cod, f else ed f the queste tre complessità e utilizzado la otazioe O avremo che la complessità dell if è pari a O(max(f cod +f the, f cod +f else )), dove il simbolo + sta ad idicare che si applica la regola della somma. Voledo ivece utilizzare la otazioe Θ, siamo costretti, come acceato ell itroduzioe, a distiguere u caso migliore ed u caso peggiore. Nel caso migliore avremo che la complessità sarà data da: Θ(mi(f cod +f the, f cod +f else )), metre el caso peggiore sarà data da Θ(max(f cod +f the, f cod +f else )). Ragioameti aaloghi valgoo el caso di u costrutto di tipo case. Cicli Ciclo While La complessità di u ciclo while è i geerale data dal prodotto della complessità del corpo del while stesso per il umero di volte che esso viee eseguito. I più bisoga cosiderare il tempo ecessario alla verifica della codizioe di fie ciclo. Trattadosi di ciclo o predetermiato, sarà ecessario distiguere u caso migliore ed u caso peggiore. Dette k mi e k max il umero miimo e massimo di volte che viee iterato u geerico ciclo while, e dette f cod e f corpo le fuzioi che caratterizzao le complessità derivati rispettivamete dalla valutazioe della codizioe e dalle istruzioi che compogoo il corpo del while, avremo che, el caso migliore, la complessità sarà data da Θ(f cod + k mi f corpo )), metre el caso peggiore sarà pari a Θ(f cod + k max f corpo )),. Si oti che è ecessario cosiderare ache f cod visto che k mi (e ache k max ) potrebbe essere pari a 0. Utilizzado la otazioe O ache i questo caso è possibile avere u uica espressioe per esprimere la complessità del ciclo while, che sarà ifatti data da O(f cod + k max f corpo )). Ciclo For La complessità di u ciclo for è data dal prodotto della complessità del corpo del for stesso per il umero di volte che esso viee eseguito. Ache i questo caso bisoga teer coto del fatto che è ecessario valutare il tempo ecessario all iizializzazioe della variabile di ciclo, al cofroto co la codizioe di fie ciclo e all icremeto della variabile stessa, tempo che tipicamete è costate. Detta quidi geericamete f cod la fuzioe che caratterizza tali tempi, detta ivece f corpo la fuzioe che caratterizza le complessità derivate dalle istruzioi che compogoo il corpo del for ed idicate co k il umero di iterazioi, si avrà che la complessità del for è data da Θ(f cod + k f corpo ). Si oti tuttavia che, dal mometo che i C il for di fatto o implemeta u ciclo predetermiato, ella pratica valgoo le stesse cosiderazioi fatte el caso del while. Chiamate di fuzioi La complessità di ua chiamata di fuzioe è data dalla somma di due termii: il costo, i termii di complessità computazioale, dell esecuzioe della fuzioe stessa ed il costo della chiamata. Quest ultimo è i geere trascurabile, ma o lo è se si effettuao chiamate per valore che hao l effetto di copiare sullo stack la struttura dati d la cui dimesioe è proprio quella da cui dipede la ostra fuzioe T() di iteresse. Tuttavia, se la struttura dati è u vettore ed il liguaggio cosiderato è il C, poiché alla fuzioe viee passato di fatto il putatore al primo elemeto del vettore, il tempo di chiamata è idipedete da. Calcolo della complessità di fuzioi ricorsive Nel caso i cui la fuzioe di cui si vuole calcolare la complessità è ua fuzioe ricorsiva, cioè cotiee al suo itero ua chiamata a se stessa, la tecica proposta ei precedeti paragrafi o può essere semplicemete applicata. Ifatti, data ua geerica fuzioe ricorsiva R, la complessità Data ultimo aggiorameto 26/02/ Pag. 6

8 della chiamata di u istaza ricorsiva di R, che compare el corpo di R stessa, dovrebbe essere data dalla somma del costo di chiamata e del costo dell esecuzioe dell istaza di R. Ma quest ultimo costo è proprio quello che stiamo cercado di calcolare, ed è quidi icogito. Per risolvere questo problema è ecessario esprimere il tempo icogito T() dell esecuzioe di R, come somma di due cotributi: u tempo Θ(f()) che deriva dall isieme di tutte le istruzioi che o cotegoo chiamate ricorsive, ed u tempo T(k) che deriva dalle chiamate ricorsive, ivocate su di ua dimesioe del dato di igresso più piccola, cioè co k <. Otterremo quidi u equazioe, detta equazioe ricorrete o formula di ricorreza o più semplicemete ricorreza, del tipo T()=aT(/b)+Θ(f() (oppure T()=aT( b)+θ(f()), dove il primo cotributo è apputo quello di a chiamate ricorsive su di u dato di dimesioe /b (oppure di b uità più piccolo) rispetto a quello di parteza ed il secodo cotributo è quello legato a tutte le istruzioi della fuzioe i cui o compaioo chiamate ricorsive. Per completare la ricorreza (e permettere la risoluzioe) è ecessario ache valutare il tempo impiegato dalla fuzioe per valori di sufficietemete piccoli. I questi casi (tipicamete per =0 o =) la fuzioe termia seza attivare chiamate ricorsive e se e può quidi calcolare semplicemete il tempo di esecuzioe T(), che sarà i geerale costate. Ad esempio, ell ambito del paradigma divide-et-impera, avremo ricorreze del tipo: Θ () per c T ( ) =, derivati dall aver diviso u certo problema padre at ( / b) + C( ) + D( ) per > c i a sottoproblemi figlio di dimesioe /b, avedo idicato co C() il costo derivate dalla combiazioe dei risultati e co D() il costo relativo alla divisioe del problema padre ei problemi figlio ed essedo costate (e quidi pari a Θ()) il tempo per la soluzioe dei problemi el caso baale, cioè quado c. Per risolvere ua formula di ricorreza, e quidi giugere a determiare la complessità asitotica di T(), è ecessario adottare dei particolari metodi di soluzioe che sarao presetati e discussi el prossimo paragrafo. Formule di ricorreza: Metodi di soluzioe I metodi proposti per la soluzioe delle formule di ricorreza soo sostazialmete tre: il metodo iterativo, il metodo di sostituzioe ed il metodo pricipale. Il primo metodo cosiste semplicemete ell iterare la ricorreza proposta, fiché o si riesce a trovare ua geeralizzazioe. A questo puto occorre trovare il valore per il quale si chiude la ricorreza, sostituirlo ella formula geerale e calcolare il risultato applicado le regole per limitare le sommatorie. I geerale è quidi ecessario fare u po di passaggi matematici (che o dovrebbero essere comuque particolarmete complessi). Il metodo di sostituzioe cosiste ell ipotizzare ua soluzioe cadidata e dimostrare l esattezza dell ipotesi sulla base dell iduzioe matematica. Il problema si ricoduce duque alla scelta della fuzioe cadidata. Nel caso i cui la fuzioe scelta o si dimostri corretta, sarà ecessario provare co u altra fuzioe. Il metodo pricipale, viceversa, permette di trovare direttamete la soluzioe i u certo umero di casi. I particolare questo metodo si può applicare a fuzioi la cui formula di ricorreza sia del tipo T()=aT(/b)+f(), cioè il problema padre è divisibile i a problemi figlio tutti di dimesioi /b rispetto al padre, ed f() è il costo della fase di divisioe e combiazioe. I tal caso occorre cofrotare la fuzioe f() co la fuzioe log b a : la complessità risultate sarà quella della fuzioe di ordie maggiore; se le due fuzioi soo dello stesso ordie comparirà u termie logaritmico ella soluzioe dell equazioe di ricorreza. Più precisamete, el caso i cui f() Θ ( log b a ), cioè f() e log b a soo dello stesso ordie di gradezza, la soluzioe dell equazioe di ricorreza sarà Θ(f() log ); se viceversa f() O( log b a-ε ) per qualche ε > 0 (questo equivale a dire che la fuzioe f() è maggiorata poliomialmete da log b a ) la complessità risultate sarà data ovviamete dalla maggiore delle due Data ultimo aggiorameto 26/02/ Pag. 7

9 fuzioi, cioè la soluzioe della ricorreza sarà Θ ( log b a ). L ultimo caso è quello i cui si verifica che f() Ω( log b a+ε ) per qualche ε > 0 e i più è ache verificata ua codizioe di regolarità, cioè a f(/b) c f() per qualche c <. I tal caso la fuzioe f() maggiora poliomialmete log b a e quidi la soluzioe sarà Θ(f()). Esempi Calcolo del fattoriale it fattoriale(it ){ if (==) retur ; else retur *fattoriale(-); Θ () per = La formula di ricorreza è data i questo caso da: T ( ) =. Ifatti el T ( ) + Θ () per > caso base, quado ==, la complessità è Θ() perché bisoga solo effettuare u cofroto e poi restituire. Nel passo iduttivo, si spede u tempo Θ() per la verifica della codizioe dell if e acora Θ() per il prodotto e la restituzioe del risultato, metre la chiamata viee effettuata su ua dimesioe che è di u uità più piccola: quidi la complessità sarà data da T( ) + Θ(). Risolviamo la ricorreza co il metodo iterativo: T() = T( ) + Θ() = (T( 2) + Θ()) + Θ() = ((T( 3) + Θ()) + Θ())+ Θ(); da cui geeralizzado, otteiamo: k T() = T( k) + Θ (). La ricorreza si chiude quado k =. I questo caso ifatti l argometo di T( ) sarà pari ad uo ed arriveremo al caso baale T()= Θ(). Quidi sostituedo otteiamo: T() = T() + Θ () = Θ() + Θ () = Θ () =Θ(). La Torre di Haoi typedef it piolo; void muovi(it disco, piolo sorgete, piolo destiazioe) { pritf("muovi il disco %2d da %2d a %2d\", disco, sorgete, destiazioe); void haoi(it, piolo sorgete, piolo destiazioe, piolo ausiliario) { if ( == ) muovi(, sorgete, destiazioe); else { haoi(-, sorgete, ausiliario, destiazioe); muovi(, sorgete, destiazioe); haoi(-, ausiliario, destiazioe, sorgete); Data ultimo aggiorameto 26/02/ Pag. 8

10 La fuzioe muovi() ha complessità Θ(), essedo composta da u uica istruzioe di stampa. Θ () per = Allora la formula di ricorreza sarà data da: T ( ) =. Ifatti el caso 2T ( ) + Θ () per > baale devo effettuare solo u cofroto e la chiamata di muovi(), che hao etrambe complessità Θ(). Nel passo iduttivo ho ivece due chiamate ricorsive, su di u argometo di u uità più piccolo (che costao quidi 2T( )) ed ua chiamata di muovi() che ha complessità Θ(). Posso acora risolvere la ricorreza co il metodo iterativo: T() = 2T( ) + Θ() = 2(2T( 2) + Θ()) + Θ() = 2(2(2T( 3) + Θ()) + Θ())+ Θ(); effettuado le moltiplicazioi ottego: T() = 8T( 3) + 4Θ() + 2Θ() + Θ() da cui geeralizzado: T() = 2 k k T( k) + 2 i Θ () = 2 k T( k) + k i Θ Acora ua volta la ricorreza si chiude quado k =. I questo caso ifatti l argometo di T( ) sarà pari ad uo ed arriveremo al caso baale T()= Θ(). Quidi sostituedo otteiamo: T() = 2 - T() + 2 i Θ 2 = 2 - Θ() i Θ 2 = 0 i Θ 2. 0 La sommatoria i paretesi o è altro che la serie geometrica. I geere: + i x 2 x =. Nel ostro caso allora avremo: i 2 = = 2, da cui sostituedo ella 0 x 0 2 relazioe precedetemete trovata risulta: T() = Θ ( 2 ) = Θ ( 2 ). MergeSort #defie MAX_SIZE 000 typedef it Vettore[MAX_SIZE]; void Merge(Vettore vet, it i, it j, it k) { Vettore aux; it p, p = i, p2 = j + ; for (p = i; p <=k; p++) if (p > j) aux[p] = vet[p2++]; else if (p2 > k) aux[p] = vet[p++]; else if (vet[p] <= vet[p2]) aux[p] = vet[p++]; else aux[p] = vet[p2++]; for (p = i; p <= k; p++) vet[p] = aux[p]; La complessità della fuzioe Merge() è data dalla somma della complessità delle iizializzazioi e delle complessità dei due cicli for. Questi ultimi hao etrambi u corpo di complessità Θ() che viee eseguito volte. La complessità della Merge() è duque Θ() + Θ() + Θ() che per la regola della somma risulta essere uguale a Θ(). Data ultimo aggiorameto 26/02/ Pag. 9

11 void MergeSort(Vettore vet, it i, it j) { if (i < j) { MergeSort(vet, i, (i+j)/2); MergeSort(vet, (i+j)/2 +, j); Merge(vet, i, (i+j)/2, j); Θ () per = La formula di ricorreza i questo caso è data da: T ( ) =. 2T ( / 2) + Θ ( ) per > Ifatti el caso baale (vettore vuoto o composto da u uico elemeto) devo effettuare solo u cofroto che ha chiaramete complessità Θ(). Nel passo iduttivo ivece devo effettuare u cofroto, co costo Θ(), più due chiamate ricorsive su di u vettore di dimesioe metà, che costao 2T(/2), più ua chiamata di Merge() sull itero vettore, chiamata che ha quidi complessità Θ() (che i questo caso rappreseta il costo di combiazioe idicato co C() el precedete paragrafo, metre o ho u costo di divisioe D()). Di uovo, per la regola della somma, Θ() + Θ() = Θ(). Risolviamo dapprima la ricorreza co il metodo iterativo. T() = 2T(/2) + Θ() = 2(2T(/4) + Θ(/2)) + Θ() = 2(2(2T(/8)+ Θ(/4)) + Θ(/2)) + Θ(); effettuado le moltiplicazioi ottego: T() = 8T(/8) + Θ() + Θ() + Θ() da cui geeralizzado: T() = 2 k T(/2 k k ) + Θ ( ). Acora ua volta la ricorreza si chiude quado l argometo di T( ) è pari ad ; i questo caso ciò si verifica quado =2 k. Ciò implica che k sarà uguale a log 2. Se sostituiamo ella precedete relazioe avremo allora: log log T() = T() + Θ ( ) =Θ()+ Θ ( ) =Θ() + Θ(log) = Θ(log). A questo risultato era possibile ache giugere direttamete applicado il metodo pricipale. Nel ostro caso ifatti, la relazioe di ricorreza è del tipo T()=aT(/b)+f(), co a = 2, b = 2 e f() = Θ(). Cofrotado allora f() = Θ() co log b a = log 2 2 =, troviamo che f() Θ( log b a ), pertato la soluzioe dell equazioe di ricorreza sarà Θ(f() log) = Θ( log). Proviamo ora ad applicare ache il metodo di sostituzioe, utilizzado chiaramete la fuzioe log come fuzioe cadidata. Per semplicità dimostriamo solo che il MergeSort() è O(log). I effetti per dimostrare l apparteeza a Θ(log), dovremmo dimostrare ache che il MergeSort() è Ω(log), dimostrazioe che, per brevità, sarà omessa. Coduciamo la dimostrazioe per iduzioe. Partiamo dal passo iduttivo: dobbiamo dimostrare che T() c log, suppoedo per iduzioe completa che T(/2) c (/2) log(/2). Sostituedo l ipotesi iduttiva ella ricorreza T()=2T(/2) +, otteiamo: T() 2 c (/2) log(/2) + = c (log log2) + = c log c+ c log. L ultimo passaggio è evidetemete valido per c. Per completare la dimostrazioe dobbiamo dimostrare ache la base, cioè che, per u certo k, sia T(k) c klogk. Normalmete come valore di k viee scelto 0 oppure. I questo caso tuttavia, scegliere k pari ad porta a dover dimostrare la diseguagliaza T() c log, che equivale a dover dimostrare T() 0, il che è impossibile. Il pricipio d iduzioe, tuttavia, dice che, dimostrato il passo iduttivo, basta dimostrare il caso base per u certo valore di k per garatire la verità dell asserto per tutti gli k. Dimostrare quidi l asserto T(k) c klogk per k = 2 garatisce che tale asserto sia vero per tutti gli 2. Ciò è più che sufficiete, dal mometo siamo iteressati a Data ultimo aggiorameto 26/02/ Pag. 0

12 dimostrare la veridicità di ua otazioe asitotica. Dobbiamo quidi dimostrare che T(2) c 2log2. Il primo membro, applicado la defiizioe iduttiva è pari a 4; otteiamo pertato 4 2 c, che risulta evidetemete vero per ogi c 2. QuickSort it Partitio(it *vet,it i,it j){ it first,last,pivot; pivot = vet[i]; first = i-; last = j+; for(;;){ do last--; while (vet[last]>pivot); do first++; while (vet[first]<pivot); if (first<last) swap(vet,first,last); else retur last; La complessità della fuzioe Partitio() è data dalla somma della complessità delle iizializzazioi e della complessità del ciclo for. Quest ultimo ha ua complessità Θ() i quato l istruzioe di retur, che determia la fie del ciclo viee raggiuta dopo l esecuzioe di u umero di istruzioi dell ordie di. void QuickSort(it *vet, it i,it j){ it k; if (i < j){ k = Partitio(vet,i,j); QuickSort(vet,i,k); QuickSort(vet,k+,j); La formula di ricorreza i questo caso dipede da come lavora la fuzioe Partitio(), il cui costo rappreseta il costo di divisioe che era stato idicato co D() el precedete paragrafo, metre o c è u costo di combiazioe C(). Nel caso i cui l idice k restituito da Partitio() è tale da dividere il vettore i due sottovettori di dimesioe metà, la formula di ricorreza è evidetemete la stessa trovata per il MergeSort, cioè: Θ () per = T ( ) =. Ifatti el caso baale (vettore vuoto o composto da u uico 2T ( / 2) + Θ ( ) per > elemeto) devo effettuare solo u cofroto che ha chiaramete complessità Θ(). Nel passo iduttivo ivece devo effettuare ua chiamata di Partitio() sull itero vettore, co costo Θ(), e due chiamate ricorsive, su di u vettore di dimesioe metà, che costao 2T(/2). I questo caso, che è ache il caso migliore, poiché la formula di ricorreza è la stessa del MergeSort, la soluzioe sarà baalmete Θ(log). Viceversa, se l idice k restituito da Partitio()è tale da dividere il vettore i due sottovettori, uo di dimesioe uitaria e l altro di dimesioe, la formula di ricorreza Data ultimo aggiorameto 26/02/ Pag.

13 Θ () per = diveterà: T ( ) =. Ifatti el passo iduttivo, la complessità sarà data T ( ) + Θ ( ) per > dalla somma della complessità di Partitio()che è Θ() più la complessità delle due chiamate ricorsive, che avrao i questo caso complessità T() e T( ). Poiché T() = Θ(), avremo che el passo iduttivo, la complessità sarà data da Θ() +Θ() + T( ), che, sempre per la regola della somma, è pari a T( ) + Θ(). Risolviamo allora la ricorreza co il metodo iterativo: T() = T( ) + Θ() = (T( 2) + Θ( )) + Θ() = ((T( 3) + Θ( 2)) + Θ( )) + Θ(); da cui geeralizzado: k T() = T( k) + Θ ( i + ). La ricorreza si chiude quado k =. I questo caso ifatti l argometo di T( ) sarà pari ad uo ed arriveremo al caso baale T()= Θ(). Quidi sostituedo otteiamo: T() = T() + Θ ( i + ) = Θ() + Θ ( i + ) = Θ ( i + ) =Θ( 2 ). L ultimo passaggio deriva dal fatto che tra paretesi ho ua serie aritmetica, la cui sommatoria è pari a ( + ). 2 Il caso appea cosiderato corrispode al caso peggiore per l algoritmo QuickSort. Si può dimostrare che el caso medio la complessità del QuickSort è uguale a quella del caso migliore, cioè è Θ(log). Data ultimo aggiorameto 26/02/ Pag. 2