Dipartimento di Elettronica, Informazione e Bioingegneria API 2013/4 Equazioni alle ricorrenze @ G. Gini 2013
divide et impera - ricorsione Esempio: ordinamento di array Dimensione dei sottoinsiemi n/2,n/2 n-1,1 Poco sforzo per dividere molto per ricombinare Merge Sort Insertion Sort Molto sforzo per dividere poco per ricombinare Quick Sort Selection Sort
Equazioni alle ricorrenze Ottenere i limiti asintotici Θ e O. Tre tecniche principali di soluzione: 1. metodo di sostituzione: ipotizziamo un limite e lo dimostriamo mediante induzione matematica 2. albero di ricorsione: convertiamo la ricorrenza in un albero i cui nodi rappresentano i costi ai vari livelli e usiamo proprietà delle sommatorie 3. teorema dell'esperto (master theorem e muster theorem)
convenzioni In genere n è sempre considerato un intero, infatti la dimensione dell input è in genere un intero Per valori piccoli di n consideriamo il tempo di esecuzione costante; in genere ignoriamo le condizioni al contorno floor e ceiling Spesso dovremo ricorrere a dimostrazioni per induzione
Per induzione Caso base: T(c) vale Passo induttivo: T(n-1) -> T(n) Induzione forte: il passo induttivo diventa
Esempio di induzione Si dimostri che Caso base: n = 1 Ipotesi induttiva Dunque Per ipotesi induttiva Quindi QDE
Metodo di sostituzione ipotizzare la forma della soluzione usare l induzione matematica per trovare le costanti e dimostrare che la soluzione è corretta A volte è difficile formulare una buona ipotesi per la soluzione
esempio di sostituzione cerchiamo un limite superiore per T(n) = 2T(n/2 ) + n supponiamo T(n) = O(n lg(n)) dobbiamo mostrare che T(n) cn lg(n) per una opportuna costante c>0 supponiamo che ciò valga per T(n/2), cioèt(n/2) c n/2 lg(n/2) allora, sostituendo in T(n) abbiamo T(n) 2c n/2 lg(n/2) + n cn lg(n/2) + n = cn lg(n) -cn lg(2) + n = cn lg(n) - cn + n cn lg(n) basta che c 1 dobbiamo mostrare che la disuguaglianza vale per n = 1 (condizione al contorno e caso base dell induzione); supponiamo che sia T(1) = 1, allora per n=1, il limite T(n) cn lg(n) diventa T(1) =1 c1 lg(1) = 0? No! È in contrasto con T(1)=1 però T(n) cn lg(n) deve valere da un certo n 0 in poi, che possiamo scegliere arbitrariamente; proviamo con n 0 = 2; se T(1) = 1, allora, dalla ricorrenza abbiamo T(2) = 2T(1) + 2 = 4 e T(3) = 2T(1) + 3 = 5 ci basta determinare una costante c tale che T(2) = 4 c2 log 2 (2) e T(3) = 5 c3 log 2 (3) per cio basta prendere c 2
Problemi col metodo di sostituzione Consideriamo il seguente caso: T(n) = T(n/2 )+T(n/2)+1 Proviamo a vedere se T(n) = O(n): T(n) c n/2+c n/2 +1 = cn+1 basta prendere c=1 e siamo a posto? No! perche non abbiamo dimostrato la forma esatta della disuguaglianza dobbiamo derivare che il tutto è cn, ma cn+1 non è cn Potremmo prendere un limite più alto, e dimostrare che T(n) è O(n 2 ) (che è ovviamente vero), ma si può anche dimostrare che T(n) = O(n) usando un'accortezza mostriamo che T(n) cn-b, con b un'opportuna costante se fosse cosi, allora T(n)= O(n) T(n) c n/2 -b+c n/2 -b+1 = cn-2b+1 cn - b basta prendere b 1
Sostituzione di variabili A volte una manipolazione algebrica permette di ottenere una ricorrenza già nota Ad esempio T(n) = 2T(n 1/2 ) + lgn Ponendo m= lgn di ottiene T(2 m ) = 2T(2 m/2 ) + m Ponendo S(m) = T(2 m ) La nuova ricorrenza è S(m) = 2S(m/2)+ m che abbiamo visto ha come soluzione S(m) = O(m lgm) ripristinando otteniamo quindi T(n) = T(2m) = S(m) = O(m lgm) = O(lgn lglgn)
Metodo dell albero di ricorsione Un metodo non molto preciso, ma utile per fare una congettura da verificare poi con il metodo di sostituzione Idea: a partire dalla ricorrenza, sviluppiamo l'albero delle chiamate, indicando per ogni chiamata la sua complessità Alla fine dovremo sommare tutte le complessità dei diversi livelli
Alcune proprietà utili delle somme
Metodo dell albero di ricorsione Idea: a partire dalla ricorrenza, sviluppiamo l'albero delle chiamate, indicando per ogni chiamata la sua complessità Esempio: T(n) = T(n/3) + T(2n/3)+O(n) 1 2
Otteniamo un valore cn per ogni livello. Se l albero fosse binario completo potremmo sommare i costi cn dei k livelli, dove altezza= log 3/2 n, ma l albero non è completo
Prevediamo che la soluzione della ricorrenza sia al massimo il costo_del _livello * numero_livelli, cioè O(c n log 3/2 n), cioè O(n lgn) Però come considerare il costo delle foglie? Il costo di ogni foglia è una costante, quindi il costo totale delle foglie sarebbe Θ(n log 3/2 2 ), cioè Ω(n lgn). Proviamo a dimostrare che l ipotesi O(n lgn) è corretta. Lo facciamo col metodo di sostituzione. Dimostriamo T(n) <=d n lgn, con d costante>0. Finchè d >= c/(lg3-2/3)
Quindi abbiamo infine dimostrato anche T(n) = Θ (n lgn)
Master theorem E - una ricetta per risolvere ricorrenze della forma T(n) = at(n/b) + f(n) -il problema di dimensione n è diviso in a sottoproblemi di dimensione n/b, ognuno risolto in tempo T(n/b). Costanti a>= 1, b>1 f(n) funzione asintoticamente positiva, considera il costo per dividere e ricombinare i sottoproblemi. -Esempi: ricerca binaria, mergesort,
Il teorema dice che T(n) può essere asintoticamente limitata nei seguenti modi: In pratica confrontiamo f(n) con n log b a. La soluzione della ricorrenza è determinata dalla più grande delle due funzioni.
Applicazione del teorema T(n) = 9 T(n/3) + n a=9, b=3, f(n)= n, quindi n l og b a = n log 3 9 = Θ(n 2 ) f(n) = n = O( n log 3 9-ε ) per ε = 1 Possiamo applicare il caso 1 e concludere che T(n) = Θ(n 2 ) T(n) = T(2n/3) + 1 a=1, b=3/2, f(n)= 1, quindi n l og b a = n log 3/2 1 = n 0 =1 f(n) = Θ(n l og b a ) = 1per ε = Θ(1) Possiamo applicare il caso 2 e concludere che T(n) = Θ(lgn)
Master theorem e Muster theorem Master theorem utile per ricorrenze da divide et impera Se si riducono come n/b, se f(n) è O(n d ), il master theorem dice: Se si riducono in altri modi, ad esempio come n-b?
Muster theorem Un teorema simile per altri casi di ricorrenze che si riducono come n-b Siano T(n) una funzione su n positivi, c, a >0, b >0, d 0 costanti, f(n) una funzione O(n d ) T(n) allora c se n 1 a(t(n-b) + f(n) se n >1
Note sul muster theorem Il primo caso non si applica mai, in quanto a<1 significa no ricorsioni. Il secondo caso è piuttosto frequente e si applica ad esempio a insertion-sort Il terzo caso si applica a molti algoritmi esponenziali, ad esempio alla torre di Hanoi
Torre di Hanoi HanoiPuzzle (n) if n = 0, return HanoiPuzzle(n 1) //[Move n-1 disks to another peg] Move one disk //[Move the largest disk to the open peg] HanoiPuzzle(n 1) //[Move n-1 disks] se T(n) è il numero di mosse per risolvere HanoiPuzzle(n), la ricorrenza è T(n) = 2T(n 1) + 1. Il muster theorem: a = 2, b = 1, d = 0, ed il teorema ci dice no(n d a n/b ) = O(2 n ) cioè abbiamo 2 n mosse di dischi per risolvere il puzzle
Un esempio completo: progettare un algoritmo di complessità ottima Dato un array A di n interi scrivere una funzione che, usando il paradigma del divide et impera restituisce il massimo ed il minimo di A in tempo O(n). Verificare tale complessità tramite l impostazione e la risoluzione di un equazione di ricorrenza. SOLUZIONE. il metodo del divide et impera si basa sull idea di ridurre il problema dato, di dimensione n, a due o più problemi di dimensione inferiore. Le uniche possibilità sensate sono le seguenti: calcolare ricorsivamente il massimo ed il minimo nei due sottovettori destro e sinistro di dimensione n/2, confrontare poi i due massimi ed i due minimi dando in output il massimo e minimo globali; calcolare ricorsivamente il massimo ed il minimo del sottovettore di dimensione n-1 ottenuto eliminando il primo (o l ultimo) elemento, confrontare poi il massimo ed il minimo ottenuti con l elemento eliminato dando in output il massimo e minimo globali. Per comprendere quale dei due approcci sia migliore, proviamo a calcolarne la complessità.
primo metodo, - il tempo di esecuzione su un input di n elementi T(n) è pari al tempo di esecuzione dello stesso algoritmo su ciascuno dei due sottovettori di n/2 elementi, più il tempo necessario per confrontare i due massimi ed i due minimi; il caso base si ha quando i sottovettori sono di dimensione 1, per cui il massimo ed il minimo coincidono, e l unica operazione da fare è quella di confrontare tra loro massimi e minimi per dare in output i valori globali. L equazione di ricorrenza è dunque: T(n)=2T(n/2)+Θ(1) T(1)=Θ(1) Risolvendo questa equazione con il metodo iterativo (ma si può fare anche con il metodo dell albero), si ottiene T(n)=22T(n/22)+Θ(1)+Θ(1)=23T(n/23)+Θ(1)+Θ(1)+Θ(1)= =2k+T(n/2k )+kθ(1). Procediamo fino a quando n/2k non sia uguale ad 1 e cioè fino a quando k=log n. In tal caso, sostituendo nell espressione di T(n) e sfruttando il caso base si ha: T(n)=n+Θ(1)+log n Θ(1)=Θ(n)
secondo approccio: il tempo di esecuzione dell algoritmo su un input di n elementi, T(n) è pari al tempo di esecuzione dello stesso algoritmo su n-1 elementi più il tempo per confrontare l elemento eliminato con il massimo ed il minimo trovati; anche qui il passo base si ha per n=1 e cioè quando massimo e minimo coincidono. L equazione di ricorrenza è: T(n)=T(n-1)+Θ(1) T(1)=Θ(1) Anche questa equazione si può risolvere con il metodo iterativo ottenendo T(n)=T(n-1)+Θ(1)=T(n-2)+Θ(1)+Θ(1)= T(n-k)+kΘ(1). Procediamo fino a quando n-k=1 cioè fino a quando k=n-1 e sostituiamo nell equazione: T(n)=T(1)+(n-1)Θ(1)=Θ(n) se si tiene conto del caso base. Deduciamo dai precedenti ragionamenti che entrambi i metodi sono ugualmente corretti ed efficienti
Esercizio 1 Espansione di ricorrenze Si trovi la soluzione di: T(n) = 2 T(n=2)+5 n2 T(1) = 7 L'espansione dell albero risulta la seguente: T(n) = 2 T(n/2)+5 n 2 = 2(2T(n/4)+5(n/2) 2 )+5 n 2 = 2(2(2 T(n/8)+5 (n/4) 2 )+5(n/2) 2 )+5 n 2 Per semplicità, supponiamo che n sia una potenza di 2 e scriviamo n come 2 k.
Soluzione 1
Conosciamo la sommatoria e quindi Eseguendo i calcoli e semplificando Che è la soluzione esatta per n=2 k
Esercizio 2 Sia dato un albero binario completo con n nodi, radicato al nodo puntato dal puntatore r. Calcolare la complessità computazionale della seguente funzione, in funzione di n: link Funzione(link r) int fogliasx,fogliadx; link r1; { 1. if (!r->fsin) && (!r->fdes) 2. return r 3. else { 4. r1=r; 5. while (r1->fsin) do 6. r1=r1->fsin; 7. fogliasx=r1->dato; 8. r1=r; 9. while (r1->fdes) do 10. r1=r1->fdes; 11. fogliadx=r1->dato; 12. if (fogliasx<fogliadx) return Funzione(r->fsin) 13. else return Funzione(r->fdes); 14.} }
Soluzione 2 La funzione è ricorsiva e pertanto dobbiamo trovare un equazione di ricorrenza in funzione di n; la complessità si ottiene sommando i contributi delle varie istruzioni: le linee 1. e 2. rappresentano il caso base, che costa Θ(1); le linee 4., 7., 8. e 11. costano anch esse Θ(1); i cicli while delle linee 5. e 9. vengono ripetuti un certo numero di volte indefinto tra 1 e l altezza dell albero, infatti il primo ciclo si interrompe quando il nodo non ha figlio sinistro ed il secondo ciclo quando il nodo non ha figlio destro; le linee 12. e 13. sono chiamate ricorsive e quindi la loro complessità si dovrà scrivere come T() con un opportuno valore tra le parentesi, ma quale? Quanti nodi hanno i sottoalberi radicati ai figli sinistro e destro della radice? Possiamo dire che hanno k ed n-1-k nodi rispettivamente. In totale otteniamo: T(n)= Θ(1)+v1Θ(1)+v2Θ(1)+max(T(k), T(n-k)) dove v1 e v2 sono il numero di volte in cui vengono ripetuti i cicli delle linee 5. e 9., cioè l altezza degli alberi. Ma quanto vale l altezza? si osservi che l albero in input è binario e COMPLETO. Quindi tutti i nodi privi di figlio sinistro (ed anche di figlio destro) sono ad altezza log n, pertanto i due cicli alle linee 5. e 9. vengono ripetuti esattamente log n volte ciascuno; diventa facile calcolare max(t(k), T(n-k)): tanto il sottoalbero sinistro che quello destro contengono esattamente (n-1)/2 nodi ciascuno.
L equazione di ricorrenza diventa : T(n)= Θ(1)+Θ(log n)+ T(n/2)= Θ(log n)+ T(n/2 T(1)= Θ(1) Risolvendo per iterazione si ha: T(n)= Θ(log n)+θ(log n/2)+ T(n/22)= = = Σ i=0..k-1 Θ (log n/2 i )+ T(n/2 k )= = (si procede fino a quando n/2 k =1 e cioè k=log n) = Σ i=0..log n-1 Θ (log n/2 i )+ T(n/2 log n )= = Σ i=0..log n-1 Θ (log n)- Σ i=0..log n-1 Θ (log 2 i )+T(1)= = Θ (log 2 n)- Σ i=0..log n-1 iθ (log 2)+ Θ(1)= = Θ (log 2 n)- Θ (log 2 ) Σ i=0..log n-1 i= = Θ (log 2 n)- Θ (log 2 n) =Θ (log 2 n)
Esercizio 3 L algoritmo merge-sort non ordina gli elementi sul posto ma usa una memoria aggiuntiva di dimensione non costante per fare il merge dei due sottoarray di supporto. 1. Scrivere merge-sort-in-place e dire se cambia la complessità temporale rispetto a merge-sort. 2. Estendere merge-sort-in-place a liste doppiamente concatenate e indicarne la complessità temporale
Soluzione 3 1. Per ordinare sul posto occorre evitare di usare gli array di servizio. Ciò si ottiene shiftando la parte del sottoarray di sinistra ancora da sistemare quando viene preso un elemento da destra
La complessità di merge-in-place costa Θ(n 2 ) nel caso pessimo in quanto ad ogni ripetizione del ciclo 3-12 può richiedere di spostare j-k+1 celle, che è un numero Θ(n) Quindi la ricorrenza di merge-sort-in-place nel caso pessimo diventa T(n) = 2T(n/2) + n 2 Usando il teorema dell esperto la soluzione è Θ(n 2 ) con un peggioramento rispetto a merge-sort
Usando una lista a doppio puntatore è possibile fare il merge senza ricorrere ad array ausiliari: occorre solo modificare un numero costante di puntatori per ottenere l effetto di posizionare i nodi nel punto giusto durante il merge
In questo caso c è un solo ciclo 3-17 che viene ripetuto al più n volte. Quindi la complessità di sublist-merge-in-place èq(n) La ricorrenza di list-merge-sort-in-place è la stessa T(n) = 2 T(n/ 2 ) + n la complessità è ancora Θ(n log(n))
Esercizio 4
Soluzione 4
Esercizio 5
Soluzione 5 Provare il muster theorem?
Note per le dimostrazioni
Equazioni alle ricorrenze Tipicamente vengono da metodi divide et impera il problema di dimensione n è stato diviso in a sottoproblemi di dimensione n/b; cn k è il lavoro per ricombinare le soluzioni parziali. Vediamo come si ragiona per il teorema dell esperto Assumiamo n = b m
Con La C c sommatoria dipende da b k /a, quindi esaminiamo i 3 casi o n
b k /a < 1 b k /a = 1 a=b k quindi b k /a > 1 dato che Quindi essendo Si ottiene