Aree. ! Bioinformatica. ! Teoria dei Controlli. ! Teoria dell Informazione. ! Ricerca Operativa.

Transcript

1 0// Paradigmi algoritmici Chapter Dynamic Programming reedy. Costruisce la soluzione incrementalmente, ottimizzando qualche criterio locale. Divide-and-conquer. Divide un problema in diversi sottoproblemi, risolve ogni sottoproblema indipendentemente, e combina le soluzioni ai sottoproblemi per costruire la soluzione al problema originale. Programmazione dinamica. Divide il problema in una serie di sottoproblemi che si sovrappongono, e costruisce le soluzioni dai sottoproblemi più piccoli a quelli sempre più grandi. Programmazione Dinamica: storia Programmazione Dinamica: Applicazioni Richard Bellman. E stato il pioniere dello studio sistematico della programmazione dinamica negli anni 0. Etimologia. Programmazione dinamica = pianificazione nel tempo. programmazione matematica e non programmazione informatica Assistant Secretary of Air Force era ostile alla ricerca matematica. Bellman pensò ad un nome altisonante per evitarne il confronto. "it's impossible to use dynamic in a pejorative sense" "something not even a Congressman could object to" Aree. Bioinformatica. Teoria dei Controlli. Teoria dell Informazione. Ricerca Operativa. Informatica: teoria, grafica, Intelligenza Artificiale,. Alcni algoritmi di programmazione dinamica famosi. Viterbi for hidden Markov models. Unix diff for comparing two files. Smith-Waterman for sequence alignment. Bellman-Ford for shortest path routing in networks. Cocke-Kasami-Younger for parsing context free grammars.

2 0// Programmazione Dinamica Algoritmi che vedremo: Weighted Interval Scheduling Segmented Least Squares Knapsack Problem RNA Secondary Structure Sequence Alignment Shortest Paths in a raph. Weighted Interval Scheduling Esercizio: Longest Common Subsequence Schedulazione degli intervalli pesati Schedulazione intervalli senza pesi Problema della schedulazione degli intervalli pesati. Job j inizia ad s j, finisce a f j, ed ha peso / valore v j. Due job compatibili se non hanno intersezione. Obiettivo: trovare sottoinsieme con massimo peso di job mutuamente compatibili. v a = 9 a v b = b valore {b,e,h} = +9+ = v c c = valore {d,h} = 0+ = v d = 0 v e = 9 d e valore {a,g} = 9+8 = v f = 8 f v g = 8 g v h = h tempo Ricordiamo. L algoritmo greedy risolve il problema se tutti i pesi sono. Considerare job in ordine crescente di tempo di fine. Aggiungere job al sottoinsieme della soluzione se è compatibile con i job scelti precedentemente. Osservazione. L algoritmo greedy può dare soluzioni non ottime se ci sono pesi arbitrari. peso= 999 peso= a b tempo 8

3 0// Schedulazione degli intervalli pesati Schedulazione degli intervalli pesati Notazione. Ordinare job per tempo di fine: f f... f n. Definizione. p(j) = il più grande i < j tale che job i è compatibile con j. Esempio: p(8) =, p() =, p() = 0. Notazione. Ordinare job per tempo di fine: f f... f n. Definizione. p(j) = il più grande i < j tale che job i è compatibile con j. Esempio: tempo 9 0 Programmazione dinamica: Scelta binaria Programmazione dinamica: Scelta binaria Notazione. OPT(j) = valore della soluzione ottimale al problema con i job,,..., j. Caso : OPT contiene job j. non può contenere job incompatibili { p(j) +, p(j) +,..., j - } deve includere soluzione ottimale al problema che consiste dei rimanenti job compatibili,,..., p(j) Caso : OPT non contiene job j. sottostruttura ottima Deve includere soluzione ottimale al problema che consiste dei rimanenti job compatibili,,..., j- Notazione. OPT(j) = valore della soluzione ottimale al problema con i job,,..., j. Caso : OPT contiene job j. non può contenere job incompatibili { p(j) +, p(j) +,..., j - } deve includere soluzione ottimale al problema che consiste dei rimanenti job compatibili,,..., p(j) Caso : OPT non contiene job j. sottostruttura ottima Deve includere soluzione ottimale al problema che consiste dei rimanenti job compatibili,,..., j- # 0 se j = 0 OPT ( j) = max v j + OPT ( p( j)), OPT ( j ") { } altrimenti

4 0// Schedulazione degli intervalli pesati: Algoritmo di forza bruta Schedulazione degli intervalli pesati: Algoritmo di forza bruta Algoritmo di forza bruta. Osservazione. Algoritmo ricorsivo non è efficiente perchè ci sono molti sottoproblemi ridondanti Input: n, s,,s n, f,,f n, v,,v n Esempio. Ordinare job per tempo di fine f f... f n. Computare p(), p(),, p(n) Compute-Opt(j) { if (j = 0) return 0 else return max(v j + Compute-Opt(p(j)), Compute-Opt(j-)) } Schedulazione degli intervalli pesati: Algoritmo di forza bruta Schedulazione degli intervalli pesati: Algoritmo di forza bruta Osservazione. Algoritmo ricorsivo non è efficiente perchè ci sono molti sottoproblemi ridondanti " complessità esponenziale. Osservazione. Algoritmo ricorsivo non è efficiente perchè ci sono molti sottoproblemi ridondanti " complessità esponenziale. Esempio. Numero di chiamate ricorsive per una famiglia di istanze cresce in modo simile ad i numeri di Fibonacci. Esempio. Numero di chiamate ricorsive per una famiglia di istanze cresce in modo simile ad i numeri di Fibonacci. i p() = 0, p(j) = j- 0 p() = 0, p(j) = j- 0 T(n) = T(n-)+T(n-)+O() T(n) = T(n-)+T(n-)+O() T(n) = ( n ) F i = F i- + F i- F = F 0 = 0 F i = " i #" ˆ i " = + =,80... " ˆ = # = #0,80...

5 0// Schedulazione degli intervalli pesati: Annotazione Schedulazione degli intervalli pesati: Complessità Annotazione (Memoization). Memorizzare i risultati per ogni sottoproblema e verificare quando necessario se un sottoproblema è già stato risolto. Input: n, s,,s n, f,,f n, v,,v n Ordinare job per tempo di fine f f... f n. Compute p(), p(),, p(n) Claim. L algoritmo con l annotazione ha complessità O(n log n). Ordinamento per tempo di fine: O(n log n). Computazione di p(#) : O(n) dopo un ordinamento per tempo di inizio. esercizio da fare a casa for j = to n M[j] = empty array globale 8 Schedulazione degli intervalli pesati: Complessità Annotazione automatica Claim. L algoritmo con l annotazione ha complessità O(n log n). Ordinamento per tempo di fine: O(n log n). Computazione di p(#) : O(n) dopo un ordinamento per tempo di inizio. M-Compute-Opt(j): ogni chiamata richiede tempo O() e fa una delle due ritorna un valore già calcolato M[j] calcola una nuovo valore M[j] e fa due chiamate ricorsive Misura del progresso = numero di valori nonvuoti di M[]. inizialmente = 0, poi n. esercizio da fare a casa incremento di " al massimo totale di O(n) chiamate ricorsive. Annotazione automatica. Molti linguaggi di programmazione funzionali (e.g., Lisp) hanno un supporto built-in support per l annotazione. Non succede nei linguaggi imperativi (e.g., Java)? (defun F (n) (if (<= n ) n (+ (F (- n )) (F (- n ))))) Lisp (efficiente) static int F(int n) { if (n <= ) return n; else return F(n-) + F(n-); } Java (esponenziale) Tempo totale di M-Compute-Opt(n) è O(n). F(9) F(0) F(8) Osservazione. Tempo O(n) se job sono ordinati per tempo di inizio e per tempo di fine. F(8) F() F() F() F() F() F() F() F() F() F() F() 9 0

6 0// Schedulazione degli intervalli pesati: Trovare una soluzione Schedulazione degli intervalli pesati: Trovare una soluzione Domanda. Algoritmo di programmazione dinamica computa il valore ottimale. E se voglio una soluzione? Risposta. Necessarie operazioni di post-processing. Domanda. Algoritmo di programmazione dinamica computa il valore ottimale. E se voglio una soluzione? Risposta. Necessarie operazioni di post-processing. E nella soluzione ottimale? Schedulazione degli intervalli pesati: Trovare una soluzione Schedulazione degli intervalli pesati: Trovare una soluzione Domanda. Algoritmo di programmazione dinamica computa il valore ottimale. E se voglio una soluzione? Risposta. Necessarie operazioni di post-processing. Domanda. Algoritmo di programmazione dinamica computa il valore ottimale. E se voglio una soluzione? Risposta. Necessarie operazioni di post-processing. E nella soluzione ottimale? NO { } { v + OPT(p()), OPT() } = max { + OPT(), OPT() } = max { +, 8 } OPT( j) = max v j + OPT(p( j)), OPT( j ) OPT() = max E nella soluzione ottimale?

7 0// Schedulazione degli intervalli pesati: Trovare una soluzione Schedulazione degli intervalli pesati: Trovare una soluzione Domanda. Algoritmo di programmazione dinamica computa il valore ottimale. E se voglio una soluzione? Risposta. Necessarie operazioni di post-processing. Domanda. Algoritmo di programmazione dinamica computa il valore ottimale. E se voglio una soluzione? Risposta. Necessarie operazioni di post-processing. E nella soluzione ottimale? SI { } { v + OPT(p()), OPT() } = max { + OPT(), OPT() } = max { +, } OPT( j) = max v j + OPT(p( j)), OPT( j ) OPT() = max E nella soluzione ottimale? Schedulazione degli intervalli pesati: Trovare una soluzione Schedulazione degli intervalli pesati: Trovare una soluzione Domanda. Algoritmo di programmazione dinamica computa il valore ottimale. E se voglio una soluzione? Risposta. Necessarie operazioni di post-processing. Domanda. Algoritmo di programmazione dinamica computa il valore ottimale. E se voglio una soluzione? Risposta. Necessarie operazioni di post-processing. E nella soluzione ottimale? SI { } { v + OPT(p()), OPT() } = max { + OPT(), OPT() } = max { +, } OPT( j) = max v j + OPT(p( j)), OPT( j ) OPT() = max E nella soluzione ottimale? SI { } { v + OPT(p()), OPT(0) } = max { + OPT(0), OPT(0) } = max { + 0, 0 } OPT( j) = max v j + OPT(p( j)), OPT( j ) OPT() = max 8

8 0// Schedulazione degli intervalli pesati: Trovare una soluzione Schedulazione degli intervalli pesati: Approccio bottom-up Domanda. Algoritmo di programmazione dinamica computa il valore ottimale. E se voglio una soluzione? Risposta. Necessarie operazioni di post-processing. Run M-Compute-Opt(n) Run Find-Solution(n) Find-Solution(j) { if (j = 0) output nothing else if (v j + M[p(j)] > M[j-]) print j Find-Solution(p(j)) else Find-Solution(j-) } Programmazione dinamica bottom-up. Input: n, s,,s n, f,,f n, v,,v n Ordinare job per tempo di fine f f... f n. Computa p(), p(),, p(n) Iterative-Compute-Opt { M[0] = 0 for j = to n M[j] = max(v j + M[p(j)], M[j-]) } Complessità O(n). Numero di chiamate ricorsive n " O(n). 9 0 Schedulazione degli intervalli pesati: Approccio bottom-up Esercizio: calcolo p(j) Computazione di p(#) : O(n) dopo un ordinamento per tempo di inizio. Quindi, dati i job ordinati per tempo di inizio, come computare in tempo lineare i valori p(j)? Primo algoritmo: Input: n, s,,s n, f,,f n job ordinati per tempo di fine f f... f n. Computa-valori-p { f 0 =0 for i= to n Calcola il max j tale che f j "s i p(i)=j } 8

9 0// Esercizio: calcolo p(j) Esercizio: calcolo p(j) Computazione di p(#) : O(n) dopo un ordinamento per tempo di inizio. Quindi, dati i job ordinati per tempo di inizio, come computare in tempo lineare i valori p(j)? Computazione di p(#) : O(n) dopo un ordinamento per tempo di inizio. Quindi, dati i job ordinati per tempo di inizio, come computare in tempo lineare i valori p(j)? Primo algoritmo: Input: n, s,,s n, f,,f n job ordinati per tempo di fine f f... f n. Computa-valori-p { f 0 =0 for i= to n Calcola il max j tale che f j "s i p(i)=j } Complessità? Input: n, s,,s n, f,,f n, job ordinati per tempo di fine f f... f n. job ordinati per tempo di inizio s #() s #()... s #(n). Computa-valori-p { j=0 f 0 =0 for i= to n Calcola il max j tale che f j "s #(i) p((i))=j } Esercizio: calcolo p(j) Esercizio: calcolo p(j), esempio Computazione di p(#) : O(n) dopo un ordinamento per tempo di inizio. Quindi, dati i job ordinati per tempo di inizio, come computare in tempo lineare i valori p(j)? Input: n, s,,s n, f,,f n, job ordinati per tempo di fine f f... f n. job ordinati per tempo di inizio s #() s #()... s #(n). Computa-valori-p { j=0 f 0 =0 for i= to n Calcola il max j tale che f j "s #(i) p((i))=j } Non può essere più piccolo del valore j precedente O(n) s #(i) 0 8 (i) 8 f i i 8 8 tempo Iniziamo con () s #() =0 ed f = Quindi p(())=0, cioè p()=0 P((i)) (i) 8 9

10 0// Esercizio: calcolo p(j), esempio Esercizio: calcolo p(j), esempio tempo tempo s #(i) 0 8 (i) 8 Continuiamo con () s #() = ed f = Quindi p(())=0, cioè p()=0 s #(i) 0 8 (i) 8 Continuiamo con () s #() = ed f = Quindi p(())=0, cioè p()=0 f i i 8 P((i)) (i) 8 f i i 8 P((i)) (i) 8 8 Esercizio: calcolo p(j), esempio Esercizio: calcolo p(j), esempio tempo tempo s #(i) 0 8 (i) 8 Continuiamo con () s #() = ed f = Quindi p(())=0, cioè p()=0 s #(i) 0 8 (i) 8 Continuiamo con () s #() = ed f =, f = Quindi p(())=, cioè p()= f i i 8 P((i)) (i) 8 f i i 8 P((i)) (i)

11 0// Esercizio: calcolo p(j), esempio Esercizio: calcolo p(j), esempio tempo tempo s #(i) 0 8 (i) 8 Continuiamo con () s #() = ed f =, f =, f = Quindi p(())=, cioè p()= s #(i) 0 8 (i) 8 Continuiamo con () s #() = ed f =, f =, f = Quindi p(())=, cioè p()= f i i 8 P((i)) (i) 8 f i i 8 P((i)) (i) 8 Esercizio: calcolo p(j), esempio Esercizio: calcolo p(j), esempio tempo tempo s #(i) 0 8 (i) 8 Terminiamo con (8) s #(8) =8 ed f =, f =, f =8, f =9 Quindi p((8))=, cioè p(8)= s #(i) 0 8 (i) 8 P(i) i 8 f i i 8 P((i)) (i) 8 f i i 8 P((i)) (i) 8

12 0// Segmented Least Squares. Segmented Least Squares Least squares. Problema fondamentale in statistica ed analisi numerica. Dati n punti nel piano: (x, y ), (x, y ),..., (x n, y n ). Trovare linea y = ax + b che minimizza la somma dell errore quadratico: y x Segmented Least Squares Segmented Least Squares Least squares. Problema fondamentale in statistica ed analisi numerica. Dati n punti nel piano: (x, y ), (x, y ),..., (x n, y n ). Trovare linea y = ax + b che minimizza la somma dell errore quadratico: Least squares. Problema fondamentale in statistica ed analisi numerica. Dati n punti nel piano: (x, y ), (x, y ),..., (x n, y n ). Trovare linea y = ax + b che minimizza la somma dell errore quadratico: Errore("y = ax + b", punti) = (y k ax k b) n " k= y y k ax k +b Errore("y = ax + b", punti) = (y k ax k b) n " k= y y k ax k +b x k x x k x Soluzione. Sappiamo che l errore minimo si ha quando a = n " x y ( x ) k k " k k (" y k ) k k, b = n x k ( x k ) " k " k " k " k y k a x k n 8

13 0// Insieme di punti su due linee Insieme di punti su tre linee 9 0 Segmented Least Squares Segmented Least Squares Segmented least squares. Punti si trovano approssimativamente su una sequenza di segmenti. Dati n punti nel piano (x, y ), (x, y ),..., (x n, y n ) con x < x <... < x n, trovare una sequenza di linee che minimizza f(x). Domanda. Qual è una scelta ragionevole per f(x) per bilanciare accuratezza e parsominia? bontà dell approssimazione Segmented least squares. Punti si trovano approssimativamente su una sequenza di segmenti. Dati n punti nel piano (x, y ), (x, y ),..., (x n, y n ) con x < x <... < x n, trovare una sequenza di linee che minimizza : la somma delle somme degli errori quadratici E in ogni segmento il numero delle linee L Funzione tradeoff: E + c L, per qualche costante c > 0. numero di linee y y x x

14 0// Programmazione dinamica: Multiway Choice Segmented Least Squares: Algoritmo Notazione. OPT(j) = minimo costo per punti p, p,..., p j. [con OPT(0)=0] e(i, j) = minima somma di errori quadratici per punti p i, p i+,..., p j. Per computare OPT(j): L ultimo segmento usa punti p i, p i+,..., p j per qualche i. Costo = e(i, j) + c + OPT(i-). INPUT: n, p,,p N, c Segmented-Least-Squares() { M[0] = 0 for j = to n for i = to j compute il minimo errore quadratico e ij per il segmento p i,, p j & 0 se j = 0 OPT ( j) = min { e(i, j) + c + OPT (i #) } altrimenti '& " i " j } Complessità. O(n ). for j = to n M[j] = min i j (e ij + c + M[i-]) return M[n] Collo di bottiglia = computazione di e(i, j) per O(n ) coppie, O(n) per coppia usando la formula precedente Segmented Least Squares: Algoritmo Esercizio: calcolare tutti i valori e(i,j) in O(n ) INPUT: n, p,,p N, c Segmented-Least-Squares() { M[0] = 0 for j = to n for i = to j compute the least square error e ij for the segment p i,, p j Algoritmo di forza bruta: O(n ) Suggerimento per algoritmo O(n ): calcolare valori e(i,j) per j-i=, j-i=,. calcolare e(i,j) da e(i,j-) in O() j " e(i, j) = (y k ax k b) k=i y } for j = to n M[j] = min i j (e ij + c + M[i-]) return M[n] a = n " x y ( x ) k k " k k (" y k ) k k, b = n x k ( x k ) " k " k " k y k a x k n " k x Complessità: O(n ) può essere migliorato: O(n ) pre-computando varie statistiche Esercizio da fare a casa Idea: calcolare valori (i,j) per j-i=, j-i=,. valori (i,j) da valori (i,j-) in O() Collo di bottiglia = computazione di e(i, j) per O(n ) coppie, O(n) per coppia usando la formula precedente

15 0// Esercizio: calcolare tutti i valori e(i,j) in O(n ) Segmented Least Squares: Trovare una soluzione Algoritmo di forza bruta: O(n ) Suggerimento per algoritmo O(n ): calcolare valori (i,j) per j-i=, j-i=,. calcolare valori (i,j) da quelli (i,j-) in O() y j " e(i, j) = (y k ax k b) k=i a = n " x ky k (" x k ) (" y k k ) k k, b = n x k ( x k ) " k " k " k " k y k a x k n x Soluzione: calcolare tutte le somme x in O(n k, y k, x k y k, x k, y k ) Scrivere l errore come j j j j j j k=i k=i k=i k=i k=i " (y k ax k b) = " y k + a " x k + b n a" x k y k b" y k + ab" x k k=i k=i k=i k=i k=i k=i j j j j j 8 Problema dello zaino. Knapsack Problem Problema dello zaino. Abbiamo n oggetti ed uno zaino Oggetto i pesa w i > 0 chilogrammi ed ha valore v i > 0. Zaino ha una capacità di W chilogrammi. Obiettivo: riempire zaino per massimizzare valore totale. Esempio: {, } ha valore 0. oggetti valore peso W = 8 8 Algoritmo greedy: aggiungere oggetto con peso massimo w i. Esempio: {,, } ha valore = " algoritmo greedy non ottimale. 0

16 0// Problema dello zaino Problema dello zaino Problema dello zaino. Abbiamo n oggetti ed uno zaino." Oggetto i pesa w i > 0 chilogrammi ed ha valore v i > 0. Zaino ha una capacità di W chilogrammi. Obiettivo: riempire zaino per massimizzare valore totale. Problema dello zaino. Abbiamo n oggetti ed uno zaino." Oggetto i pesa w i > 0 chilogrammi ed ha valore v i > 0. Zaino ha una capacità di W chilogrammi. Obiettivo: riempire zaino per massimizzare valore totale. Esempio: {, } ha valore 0. oggetti valore peso Esempio: {, } ha valore 0. oggetti valore peso val/peso W = 8 W = 8,, 8 8 Algoritmo greedy: aggiungere oggetto con valore massimo v i. Esempio: {,, } ha valore = " algoritmo greedy non ottimale. Algoritmo greedy: aggiungere oggetto con rapporto massimo v i / w i Esempio: {,, } ha valore = " algoritmo greedy non ottimale. Programmazione dinamica: Primo tentativo Programmazione dinamica: aggiunta nuova variabile Definizione. OPT(i) = max valore totale con sottoinsieme oggetti,, i. Caso : OPT non contiene oggetto i. OPT contiene max valore totale di {,,, i- } Caso : OPT contiene oggetto i. che l oggetto i ci sia nella soluzione non implica immediatamente che altri oggetti non ci siano senza sapere quali altri oggetti ci siano nella soluzione non sappiamo se c è spazio sufficiente per altri oggetti Definizione. OPT(i, w) = max valore totale con sottoinsieme oggetti,, i con limite di peso w. Case : OPT non contiene oggetto i. OPT contiene max valore totale di {,,, i- } con limite di peso w Case : OPT contiene oggetto i. Nuovo limite di peso = w w i OPT contiene max valore totale di {,,, i } con nuovo limite peso Conclusione. Abbiamo bisogno di più sottoproblemi

17 0// Programmazione dinamica: aggiunta nuova variabile Problema dello zaino: approccio bottom-up Definizione. OPT(i, w) = max valore totale con sottoinsieme oggetti,, i con limite di peso w. Utilizzare un array n-per-w. Case : OPT non contiene oggetto i. OPT contiene max valore totale di {,,, i- } con limite di peso w Case : OPT contiene oggetto i. Nuovo limite di peso = w w i OPT contiene max valore totale di {,,, i } con nuovo limite di peso " 0 se i = 0 OPT(i, w) = # OPT(i, w) se w i > w max OPT(i, w), { v i + OPT(i, w w i ) } altrimenti Problema dello zaino: approccio bottom-up Problema dello zaino: esempio algoritmo Utilizzare un array n-per-w. # 0 se i= 0 OPT (i, w) = OPT (i ", w) se w i > w & max{ OPT (i ", w), v i + OPT (i ", w " w i )} altrimenti v =, v =, v = Input: n, w,,w N, v,,v N for w = 0 to W M[0, w] = 0 for i = to n for w = to W if (w i > w) M[i, w] = M[i-, w] else M[i, w] = max {M[i-, w], v i + M[i-, w-w i ]} return M[n, W] 8

18 0// Problema dello zaino: esempio algoritmo Problema dello zaino: Complessità W Complessità. & ( n W ). Non polinomiale nella lunghezza dell input "Pseudo-polinomiale." Versione decisionale del problema dello zaino è NP-completo. [Cap 8] n + { } {, } {,, } {,,, } Algoritmi di approssimazione per lo zaino. Esiste un algoritmo di approssimazione polinomiale che produce una soluzione il cui valore è al massimo 0.0 rispetto all ottimale. [Sezione.8] {,,,, } Comunque, non lo tratteremo in questo corso oggetto valore peso OPT: {, } valore = + 8 = 0 W = Problema dello zaino: Esercizio Problema dello zaino: Esercizio Si descriva ed analizzi un algoritmo per la seguente variazione del problema dello zaino: Dati n oggetti di peso w,w,...,w n e valore v,v,...,v n ed uno zaino di capacità W (tutti gli input sono >0), trovare il massimo valore di un sottoinsieme degli oggetti il cui peso totale è al massimo W, con la condizione che ogni oggetto può essere preso anche più di una volta. (La variazione rispetto al problema del testo, consiste nel superamento del vincolo che ogni oggetto poteva essere preso al massimo una sola volta.) Si descriva ed analizzi un algoritmo per la seguente variazione del problema dello zaino: Dati n oggetti di peso w,w,...,w n e valore v,v,...,v n ed uno zaino di capacità W (tutti gli input sono >0), trovare il massimo valore di un sottoinsieme degli oggetti il cui peso totale è al massimo W, con la condizione che ogni oggetto può essere preso al massimo volte. (La variazione rispetto al problema del testo, consiste nel superamento del vincolo che ogni oggetto poteva essere preso al massimo una sola volta.) 8

19 0// Problema dello zaino: Esercizio. RNA Secondary Structure Si descriva ed analizzi un algoritmo per la seguente variazione del problema dello zaino: Dati n oggetti di peso w,w,...,wn e valore v,v,...,vn ed uno zaino di capacità W (tutti gli input sono >0), trovare il massimo valore di un sottoinsieme degli oggetti il cui peso totale è al massimo W, con la condizione che non possono essere presi due oggetti con indici consecutivi (ovvero gli oggetti i-esimo ed (i+)-esimo, per i=,,...,n-). enoma Umano Human enome Project Fatto di DNA che ha differenti mattoni chimici, chiamati basi: A, T, C,. Se la sequenza fosse scritta in un elenco telefonico, occorrerebbero 00 volumi di 00 pagine ognuno Iniziato Ottobre 990 Durata prevista anni Se provassimo a leggere 0 basi al secondo, cioè 00 basi/minuto,.000 basi/ora, basi/giorno, basi/anno, occorrerebbero circa 9, anni per leggere la sequenza Mb = basi (megabase) Scopo: determinare la sequenza completa delle basi ( miliardi) del DNA, identificare tutti i geni umani e renderli accessibili per ulteriori studi Per intera sequenza occorrono gigabyte, senza contare altri dati associati 9

20 0// enoma Umano Human enome Research Institute (finanziamenti pubblici USA) e Celera enomics Corporation (settore commerciale) Sequenze geniche sono brevettabili, stabilito dai tribunali (brevetto dura 0 anni) Corsa ai brevetti per Celera ed alla pubblicazione degli accademici per evitare i brevetti Corsa finita alla pari giugno 000, Tony Blair e Bill Clinton annunciano il sequenziamento completo del genoma umano Organism enome Size (Bases) Human (Homo sapiens) billion 0,000 Laboratory mouse (M. musculus). billion 0,000 Mustard weed (A. thaliana) 00 million,000 Roundworm (C. elegans) 9 million 9,000 Fruit fly (D. melanogaster) million,000 Yeast (S. cerevisiae). million,000 Bacterium (E. coli). million,00 Human immunodeficiency virus (HIV) Estimated enes 8 Crescita Banche Dati Ogni organismo ha un genoma che contiene tutte le informazioni biologiche necessarie per costruire e mantenere un esempio vivente di quell organismo Cromosoma: composto da una molecola di Dna e dalle proteine associate, contiene informazioni ereditare Le informazioni biologiche sono codificate nel suo DNA (deoxyribonucleic acid) ed è diviso in unità discrete chiamate geni Numero complessivo strutture randezza complessiva Mbp eni contengono istruzioni per costruire proteine Protein Data Bank, archivio di strutture tridimensionali di macromolecole biologiche enebank, banca dati di sequenze geniche del National Center for Biotechnology Information degli USA 9 Le proteine determinano come appare l organismo, come il corpo metabolizza cibo o combatte infezioni, e qualche 80 volta come si comporta, 0

21 0// enoma Le basi del DNA Ogni organismo ha un genoma che contiene tutte le informazioni biologiche necessarie per costruire mantenere un esempio vivente di quell organismo Le informazioni biologiche sono codificate nel suo DNA (deoxyribonucleic acid) ed è diviso in unità discrete chiamate geni eni contengono istruzioni per costruire proteine richieste dall organismo Le proteine determinano, come appare l organismo, come il corpo metabolizza cibo o combatte infezioni, e qualche volta come si comporta, 8 8 DNA Molecola formata da catene a forma di doppia elica Catene connesse da basi complementari A-T e C- James Watson e Francis Crick 8 8

22 0// Ribonucleic acid (RNA) RNA Secondary Structure Simile al DNA. Singola catena con nucleotidi: adenine (A), cytosine (C), guanine (), uracil (U). RNA. Stringa B = b b b n su alfabeto { A, C,, U }. RNA. Stringa B = b b b n su alfabeto { A, C,, U }. Struttura secondaria. RNA è una singola catena e tende a formare coppie di basi con se stessa. Questa struttura è essenziale per capire il comportamento delle molecole. coppie di base complementari: A-U, C- 8 8 RNA Secondary Structure RNA Secondary Structure RNA. Stringa B = b b b n su alfabeto { A, C,, U }. Struttura secondaria. RNA è una singola catena e tende a formare coppie di basi con se stessa. Questa struttura è essenziale per capire il comportamento delle molecole. C Esempio: UCAUUACAAUUAACAACUCUACCAA A A U C C U A C A U A U A A U A U C A Struttura secondaria. Un insieme di coppie S = { (b i, b j ) } che soddisfa: [Watson-Crick.] S è un matching ed ogni coppia in S è un complemento Watson-Crick: A-U, U-A, C-, oppure -C. C U C A U U A coppia di basi C C A C A U A U U C C A U coppie di base complementari: A-U, C- 8 88

23 0// RNA Secondary Structure RNA Secondary Structure Struttura secondaria. Un insieme di coppie S = { (b i, b j ) } che soddisfa: [Watson-Crick.] S è un matching ed ogni coppia in S è un complemento Watson-Crick: A-U, U-A, C-, oppure -C. [No sharp turns.] li elementi di ogni coppia sono separati da almeno basi. Se (b i, b j ) ' S, allora i < j. Struttura secondaria. Un insieme di coppie S = { (b i, b j ) } che soddisfa: [Watson-Crick.] S è un matching ed ogni coppia in S è un complemento Watson-Crick: A-U, U-A, C-, oppure -C. [No sharp turns.] li elementi di ogni coppia sono separati da almeno basi. Se (b i, b j ) ' S, allora i < j -. [Non-crossing.] Se (b i, b j ) e (b k, b l ) sono due coppie in S, allora non è possibile che i < k < j < l. C A U C C U U U A sharp turn A U A crossing A U C A U A U U C C A U RNA Secondary Structure RNA Secondary Structure: Sottoproblemi Struttura secondaria. Un insieme di coppie S = { (b i, b j ) } che soddisfa: [Watson-Crick.] S è un matching ed ogni coppia in S è un complemento Watson-Crick: A-U, U-A, C-, oppure -C. [No sharp turns.] li elementi di ogni coppia sono separati da almeno basi. Se (b i, b j ) ' S, allora i < j -. [Non-crossing.] Se (b i, b j ) e (b k, b l ) sono due coppie in S, allora non è possibile che i < k < j < l. Energia libera. L ipotesi usuale è che una molecola RNA formerà la struttura secondaria con l energia libera totale ottimale. approssimativamente il numero di coppie di basi Obiettivo. Data una molecola RNA B = b b b n, trovare una struttura secondaria S che massimizza il numero di coppie di basi. Primo tentativo. OPT(j) = massimo numero di coppie di basi in una struttura secondaria della sottostringa b b b j. Difficoltà. Abbiamo due sottoproblemi: Trovare la struttura secondaria in: b b b t-. Trovare la struttura secondaria in: b t+ b t+ b j-. accoppiamento b t e b j t j OPT(t-) abbiamo bisogno di più sottoproblemi 9 9

24 0// Programmazione dinamica su intervalli Programmazione dinamica su intervalli Notazione. OPT(i, j) = massimo numero di coppie di basi in una struttura secondaria della sottostringa b i b i+ b j. Case. Se i ( j -. OPT(i, j) = 0 per la condizione no-sharp turns. Case. La base b j non fa parte di una coppia. OPT(i, j) = OPT(i, j-) Case. La base b j fa coppia con b t per qualche i t < j -. Vincolo non-crossing determina i risultanti sottoproblemi OPT(i, j) = max i t<j- { + OPT(i, t-) + OPT(t+, j-) } b t e b j sono complementi Watson-Crick, cioè A-U, U-A, C-, oppure -C. Notazione. OPT(i, j) = massimo numero di coppie di basi in una struttura secondaria della sottostringa b i b i+ b j. Case. Se i ( j -. OPT(i, j) = 0 per la condizione no-sharp turns. Case. La base b j non fa parte di una coppia. OPT(i, j) = OPT(i, j-) Case. La base b j fa coppia con b t per qualche i t < j -. Vincolo non-crossing determina i risultanti sottoproblemi OPT(i, j) = max i t<j- { + OPT(i, t-) + OPT(t+, j-) } b t e b j sono complementi Watson-Crick, cioè A-U, U-A, C-, oppure -C. 9 # 0 i j " i j " OPT(i, j) = " OPT(i, j-) max{ # max OPT(i, j), + max { + { OPT(i, t-) + OPT(t+, j-) j-) }} } altrimenti & it<j- b jb t complementi 9 Bottom Up Dynamic Programming Over Intervals Domanda. In che ordine risolvere i sottoproblemi? Risposta. Dapprima gli intervalli più corti. " OPT(i, j-) OPT(i, j) =max# max it<j- 8 9 A C C U A U b jb t complementi { + OPT(i, t-) + OPT(t+, j-) } k è la lunghezza intervallo j-i RNA(b,,b n ) { for k =,,, n- for i =,,, n-k j = i + k Compute M[i, j] i " OPT(, 8) = 0 OPT(, 9) =max# max { + OPT(, t-) + OPT(t+, 8) }=0 t< b 9b t complementi U A U } return M[, n] 8 9 j " OPT(, ) = 0 OPT(, 8) =max# max { + OPT(, t-) + OPT(t+, ) }= t< b 8b t complementi C U A Complessità. O(n ). usare ricorrenza " OPT(i, j-) OPT(i, j) =max# max it<j- b jb t complementi { + OPT(i, t-) + OPT(t+, j-) } " OPT(, ) = 0 OPT(, ) =max# max { + OPT(, t-) + OPT(t+, ) }=0 C C U A t< b b t complementi " OPT(, ) = 0 OPT(, ) =max# max { + OPT(, t-) + OPT(t+, ) }= t< A C C U b b t complementi 9 9

25 0// 8 9 A C C U A U 8 9 A C C U A U " OPT(, 8) = OPT(, 9) =max# max { + OPT(, t-) + OPT(t+, 8) }=0 t< b 9b t complementi " OPT(, ) = 0 OPT(, 8) =max# max { + OPT(, t-) + OPT(t+, ) }= t< b 8b t complementi " OPT(, ) = OPT(, ) =max# max { + OPT(, t-) + OPT(t+, ) }=0 t< b b t complementi C U A U oppure C C U A C C U A t= t= A C C U A " OPT(, 8) = OPT(, 9) =max# max t< b 9b t complementi " OPT(, ) = OPT(, 8) =max# max t< b 8b t complementi { + OPT(, t-) + OPT(t+, 8) }=0 { + OPT(, t-) + OPT(t+, ) }= C C U A U A C C U A A C C U A U Trovare una soluzione " OPT(, 9) =max# OPT(, 8) = max t< b 9b t complementi { + OPT(, t-) + OPT(t+, 8) }= max per t= OPT(,9) = + OPT(,8) U C A A C C U A U C A U 99 00

26 0// Programmazione dinamica: sommario Ricetta. Caratterizza struttura del problema. Definire ricorsivamente valore della soluzione ottimale. Computare valore soluzione ottimale. Costruire soluzione ottimale dalle informazioni computate.. Sequence Alignment Tecniche di Programmazione dinamica. Scelta binaria: weighted interval scheduling. Multi-way choice: segmented least squares. Aggiunta di una nuova variabile: knapsack. Programmazione dinamica su intervalli: RNA secondary structure. Top-down vs. bottom-up: persone diverse hanno diverse intuizioni. 0 Similarità di stringhe Edit Distance Quanto sono simili due stringhe? ocurrance occurrence o c u r r a n c e - o c c u r r e n c e Applicazioni. Base per diff di Unix. Riconoscimento voce. Biologia Computazionale. o c - mismatches, gap u r r a n c e Edit distance. [Levenshtein 9, Needleman-Wunsch 90] Penalità per gap ); penalità per mismatch * pq. Costo = somma delle penalità di gap e mismatch. o c c u r r e n c e mismatch, gap C T A C C T A C C T - C T A C C T A C C T o c - u r r - a n c e C C T A C T A C A T C C T A C - T A C A T o c c u r r e - n c e * TC + * T + * A + * CA ) + * CA 0 mismatches, gaps 0 0

27 0// Sequence Alignment Sequence Alignment: Struttura del problema Obiettivo: Date due stringhe X = x x... x m e Y = y y... y n trovare un allineamento di costo minimo. Definizione. Un allineamento M è un insieme di coppie ordinate x i -y j tali che ogni elemento occorre in al massimo una coppia e senza cross. Definizione. OPT(i, j) = min costo allineamento x x... x i e y y... y j. Caso : OPT accoppia x i -y j. mismatch per x i -y j + min costo allineamento x x... x i- e y y... y j- Caso a: OPT lascia x i senza accoppiamento. Definizione. La coppia x i -y j e x i' -y j' cross se i < i', ma j > j'. gap per x i e minimo costo allineamento x x... x i- e y y... y j Caso b: OPT lascia y j senza accoppiamento. Esempio: CTACC vs. TACAT. Allineamento: M = x -y, x -y, x -y, x -y, x -y. costo(m ) = " xi y j ( x i,y j ) # M # "# mismatch + + i : x i non accoppiato j : y j non accoppiato #### #" ###### gap x x x x x x C T A C C - - T A C A T y y y y y y gap per y j e minimo costo allineamento x x... x i e y y... y j- " j& se i= 0 " ' xi y j +OPT (i (, j () OPT (i, j) = # min # & +OPT (i (, j) altrimenti & +OPT (i, j () i& se j = Sequence Alignment: Algoritmo Sequence Alignment: Algoritmo Sequence-Alignment(m, n, x x...x m, y y...y n, ), *) { for i = 0 to m M[0, i] = i) for j = 0 to n M[j, 0] = j) } for i = to m for j = to n M[i, j] = min(*[x i, y j ] + M[i-, j-], ) + M[i-, j], ) + M[i, j-]) return M[m, n] 0 08

28 0// Sequence Alignment: Esempio algoritmo Sequence Alignment: Esempio algoritmo Penalità per gap ) = Penalità per gap ) = Penalità per mismatch * vocale,vocale = * consonante,consonante = * vocale,consonante = Penalità per mismatch * vocale,vocale = * consonante,consonante = * vocale,consonante = M[,] = min(+m[,], +M[,], +M[,]) = min( 8,, ) = M[,] = min(+m[,], +M[,], +M[,]) = min( 8,, ) = m e a n - n - a m e = 09 0 Sequence Alignment: Complessità algoritmo Sequence Alignment: Linear Space Sequence-Alignment(m, n, x x...x m, y y...y n, ), *) { for i = 0 to m M[0, i] = i) for j = 0 to n M[j, 0] = j) } for i = to m for j = to n M[i, j] = min(*[x i, y j ] + M[i-, j-], ) + M[i-, j], ) + M[i, j-]) return M[m, n] Analisi. &(mn) tempo e spazio. Parole o frasi in italiano o inglese: m, n 0. Biologia Computazionale: m = n = Va bene per 0 miliardi operazioni, ma array 0B? Domanda. Possiamo usare meno spazio? Facile. Valore ottimo in spazio O(m + n) e tempo O(mn). Computare OPT(i, ) da OPT(i-, ). Non è più facile computare un allineamento ottimale. Teorema. [Hirschberg 9] Allineamento ottimo in spazio O(m + n) e tempo O(mn). Combinazione di divide-and-conquer e programmazione dinamica.. Sequence Alignment in Linear Space ma non lo tratteremo 8

29 0// Shortest Paths.8 Shortest Paths Problema del cammino più corto. Dato un grafo diretto = (V, E), con peso degli archi c vw, trovare il cammino più corto dal nodo s al nodo t. anche pesi negativi Esempio. I nodi rappresentano agenti in ambito finanziario c vw è il costo di una transazione nella quale si acquista da v e si vende a w. Un cammino rappresenta una successione di transazioni. s t Shortest Paths: Approcci che non funzionano Shortest Paths: Approcci che non funzionano Algoritmo di Dijkstra. Potrebbe non funzionare con costi negativi. Algoritmo di Dijkstra. Potrebbe non funzionare con costi negativi. u u s t - v s t - v Scalare il peso degli archi. Aggiungere una costante ad ogni peso degli archi potrebbe non funzionare. s t - 9

30 0// Shortest Paths: Approcci che non funzionano Shortest Paths: Ciclo con costo negativo Algoritmo di Dijkstra. Potrebbe non funzionare con costi negativi. Ciclo con costo negativo. s Scalare il peso degli archi. Aggiungere una costante ad ogni peso degli archi potrebbe non funzionare. s u t v t Osservazione. Se un cammino da s a t contiene un ciclo con costo negativo, non esiste un cammino s-t più corto; comunque, ne esiste uno che è semplice. Assumiamo che il grafo non contenga cicli con costo negativo - - s W c(w) < 0 t 8 Shortest Paths: Programmazione dinamica Shortest Paths: Programmazione dinamica Definizione. OPT(i, v) = lunghezza del cammino P più corto v-t usando al massimo i archi. Caso : P usa al massimo i- archi. OPT(i, v) = OPT(i-, v) Caso : P usa esattamente i archi. se (v, w) è il primo arco, allora OPT usa (v, w), e poi sceglie il miglior cammino w-t usando al massimo i- archi OPT(i, v) = OPT(i-, w) + c vw Definizione. OPT(i, v) = lunghezza del cammino P più corto v-t usando al massimo i archi. Caso : P usa al massimo i- archi. OPT(i, v) = OPT(i-, v) Caso : P usa esattamente i archi. se (v, w) è il primo arco, allora OPT usa (v, w), e poi sceglie il miglior cammino w-t usando al massimo i- archi " 0 se v = t " OPT (i, v) = # min OPT (i &, v), min OPT (i &, w)+ c ( # { vw } ) altrimenti (v, w) ' E * + se i= 0,v, t Nota. OPT(n-, v) = lunghezza del cammino v-t più corto (Ricorda che non ci sono cicli con costo negativo) 9 0 0

31 0// Shortest Paths: Esempio Shortest Paths: Esempio " 0 se v = t " OPT (i, v) = # min OPT (i &, v), min OPT (i &, w)+ c ( # { vw } ) altrimenti (v, w) ' E * + se i= 0,v, t " 0 se v = t " OPT (i, v) = # min OPT (i &, v), min OPT (i &, w)+ c ( # { vw } ) altrimenti (v, w) ' E * + se i= 0,v, t Ricorda: OPT(n-, v) = lunghezza del cammino v-t più corto OPT(, a) = lunghezza del cammino a-t più corto Qual è il cammino a-t più corto? Come lo calcoliamo a partire dalla matrice? Shortest Paths: Esempio Shortest Paths: Esempio " 0 se v = t " OPT (i, v) = # min OPT (i &, v), min OPT (i &, w)+ c ( # { vw } ) altrimenti (v, w) ' E * + se i= 0,v, t " 0 se v = t " OPT (i, v) = # min OPT (i &, v), min OPT (i &, w)+ c ( # { vw } ) altrimenti (v, w) ' E * + se i= 0,v, t OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) OPT(n-, v) = lunghezza del cammino v-t più corto OPT(, a) = lunghezza del cammino a-t più corto OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) a-b Qual è il cammino a-t più corto? Quindi, OPT(,a) = OPT(,b) + c ab OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) Quindi, OPT(,a) = OPT(,a)

32 0// Shortest Paths: Esempio Shortest Paths: Esempio " 0 se v = t " OPT (i, v) = # min OPT (i &, v), min OPT (i &, w)+ c ( # { vw } ) altrimenti (v, w) ' E * + se i= 0,v, t " 0 se v = t " OPT (i, v) = # min OPT (i &, v), min OPT (i &, w)+ c ( # { vw } ) altrimenti (v, w) ' E * + se i= 0,v, t OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) a-b OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) a-b OPT(,b) = min( OPT(,b), min(opt(,e)+c be,opt(,d)+c bd ) = min( 0, min(0-,-) ) b-e OPT(,b) = min( OPT(,b), min(opt(,e)+c be,opt(,d)+c bd ) = min( 0, min(0-,-) ) b-e OPT(,e) = min( OPT(,e), min(opt(,c)+c ec,opt(,t)+c et ) = min(, min(-,0+) ) e-c Quindi, OPT(,b) = OPT(,e) + c be Quindi, OPT(,e) = OPT(,c) + c ec Shortest Paths: Esempio Shortest Paths: Esempio " 0 se v = t " OPT (i, v) = # min OPT (i &, v), min OPT (i &, w)+ c ( # { vw } ) altrimenti (v, w) ' E * + se i= 0,v, t " 0 se v = t " OPT (i, v) = # min OPT (i &, v), min OPT (i &, w)+ c ( # { vw } ) altrimenti (v, w) ' E * + se i= 0,v, t OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) a-b OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) a-b OPT(,b) = min( OPT(,b), min(opt(,e)+c be,opt(,d)+c bd ) = min( 0, min(0-,-) ) b-e OPT(,b) = min( OPT(,b), min(opt(,e)+c be,opt(,d)+c bd ) = min( 0, min(0-,-) ) b-e OPT(,e) = min( OPT(,e), min(opt(,c)+c ec,opt(,t)+c et ) = min(, min(-,0+) ) e-c OPT(,e) = min( OPT(,e), min(opt(,c)+c ec,opt(,t)+c et ) = min(, min(-,0+) ) e-c OPT(,c) = min( OPT(0,e), min(opt(0,b)+c cb,opt(0,t)+c ct ) = min( +, min(+-8,0+) ) c-t OPT(,c) = min( OPT(0,e), min(opt(0,b)+c cb,opt(0,t)+c ct ) = min( +, min(+-8,0+) ) c-t Quindi, OPT(,c) = OPT(0,t) + c ct a b e c t = - 8

33 0// Shortest Paths: Esempio Shortest Paths: Esempio " 0 se v = t " OPT (i, v) = # min OPT (i &, v), min OPT (i &, w)+ c ( # { vw } ) altrimenti (v, w) ' E * + se i= 0,v, t Trovare il cammino più corto. Qual è l informazione " 0 che possiamo ricordare? se v = t " OPT (i, v) = # min# OPT (i &, v), min { OPT (i &, w)+ c ( vw } ) altrimenti (v, w) ' E * + se i= 0,v, t OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) a-b OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) a-b OPT(,b) = min( OPT(,b), min(opt(,e)+c be,opt(,d)+c bd ) = min( 0, min(0-,-) ) b-e OPT(,b) = min( OPT(,b), min(opt(,e)+c be,opt(,d)+c bd ) = min( 0, min(0-,-) ) b-e OPT(,e) = min( OPT(,e), min(opt(,c)+c ec,opt(,t)+c et ) = min(, min(-,0+) ) e-c OPT(,e) = min( OPT(,e), min(opt(,c)+c ec,opt(,t)+c et ) = min(, min(-,0+) ) e-c OPT(,c) = min( OPT(0,e), min(opt(0,b)+c cb,opt(0,t)+c ct ) = min( +, min(+-8,0+) ) c-t OPT(,c) = min( OPT(0,e), min(opt(0,b)+c cb,opt(0,t)+c ct ) = min( +, min(+-8,0+) ) c-t 9 0 Shortest Paths: Esempio Shortest Paths: Esercizio Trovare il cammino più corto. Qual è l informazione " 0 che possiamo ricordare? se v = t " OPT (i, v) = # min# OPT (i &, v), min { OPT (i &, w)+ c ( vw } ) altrimenti Mantenere un "successore" per (v, w) ' Eogni valore della * tabella. + se i= 0,v, t Si esegua l'algoritmo di programmazione dinamica Shortest-Path(,t) per il calcolo dei cammini minimi sul grafo u t c e b OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) OPT(,a) = min( OPT(,a), min(opt(,t)+c at,opt(,b)+c ab ) = min( -, min(0-,--) ) OPT(,b) = min( OPT(,b), min(opt(,e)+c be,opt(,d)+c bd ) = min( 0, min(0-,-) ) OPT(,e) = min( OPT(,e), min(opt(,c)+c ec,opt(,t)+c et ) = min(, min(-,0+) ) a-b b-e e-c s Si chiariscano i passi effettuati evidenziando i valori della matrice OPT costruita dall'algoritmo - t v t u v s OPT(,c) = min( OPT(0,e), min(opt(0,b)+c cb,opt(0,t)+c ct ) = min( +, min(+-8,0+) ) c-t Si descriva come ottenere il cammino di costo minimo dal nodo u facendo uso della matrice OPT e chiarendo i passi effettuati.

34 0// Shortest Paths: Implementazione Shortest Paths: Implementazione Shortest-Path(, t) { array M[0 n-,v] foreach node v ' V M[0, v], + M[0, t], 0 Shortest-Path(, t) { array M[0 n-,v] foreach node v ' V M[0, v], + M[0, t], 0 } for i = to n- foreach node v ' V M[i, v], M[i-, v] foreach edge (v, w) ' E M[i, v], min { M[i, v], M[i-, w] + c vw } } for i = to n- foreach node v ' V M[i, v], M[i-, v] foreach edge (v, w) ' E M[i, v], min { M[i, v], M[i-, w] + c vw } Analisi. Tempo &(mn), spazio &(n ). Shortest Paths: Miglioramenti pratici Shortest Paths: Miglioramenti pratici Miglioramenti pratici. Mantenere solo un array M[v] = cammino più corto v-t che abbiamo trovato finora. ( i è solo un contatore) # M(i, v) = min M(i, v), la relazione si semplifica : Shortest-Path(, t) { array M[V] foreach node v ' V M[v], + M[t], 0 } min { M(i, w)+ c vw } (v, w) " E " M(v) = min# M(v), for i = to n- foreach edge (v, w) ' E M[v], min { M[v], M[w] + c vw } & ' ( min { M(w)+ c vw } (v, w) E & ' Miglioramenti pratici. Mantenere solo un array M[v] = cammino più corto v-t che abbiamo trovato finora. Nessuna necessità di controllare archi della forma (v, w) a meno che M[w] è cambiato nell iterazione precedente. Teorema. Durante l algoritmo, M[v] è la lunghezza di un cammino v-t, e dopo i round di aggiornamenti, il valore M[v] non è maggiore della lunghezza del cammino v-t più corto usando i archi. Impatto totale. Memoria: O(m + n). Complessità tempo: caso peggiore O(mn), ma veloce in pratica.

35 0// Esercizio: Longest Common Subsequence Esercizio: Longest Common Subsequence Problema: Date sequenze, X = x x m e Y = y y n, trovare una sottosequenza comune la cui lunghezza è massima. springtime ncaa tournament basketball Problema: Date sequenze, X = x x m e Y = y y n, trovare una sottosequenza comune la cui lunghezza è massima. springtime ncaa tournament basketball printing north carolina krzyzewski Algoritmo naïve: &(n m ) (per ogni sottosequenza di X, verificare se è anche sottosequenza di Y) printing north carolina krzyzewski Algoritmo naïve: &(n m ) (per ogni sottosequenza di X, verificare se è anche sottosequenza di Y) Descrivere ed analizzare un algoritmo di programmazione dinamica Suggerimento: la tecnica è simile a quella per Sequence Alignment 8 Longest Common Subsequence: sottostruttura ottimale Longest Common Subsequence: soluzione ricorsiva Sia Z = z... z k una LCS di X e Y. Se x m = y n, allora z k = x m = y n e Z k- è una LCS di X m- e Y n-. Se x m - y n, allora z k - x m e Z è una LCS di X m- e Y oppure z k - y n e Z è una LCS di X e Y n- Sia Z = z... z k una LCS di X e Y. Se x m = y n, allora z k = x m = y n e Z k- è una LCS di X m- e Y n-. Se x m - y n, allora z k - x m e Z è una LCS di X m- e Y oppure z k - y n e Z è una LCS di X e Y n- Notazione: X i = x x i è un prefisso di X Y i = y y i è un prefisso di Y Definiamo c[i,j] = lunghezza della LCS di X i e Y j La soluzione del problema è data da c[m,n]. # 0 se i = 0 oppure j = 0, c[i, j] = c[i, j ]+ se i, j > 0 e x i = y j, max(c[i, j], c[i, j ]) se i, j > 0 e x i " y j. & 9 0

36 0// Longest Common Subsequence: algoritmo iterativo Longest Common Subsequence: esempio LCS (X, Y) m length[x] n length[y] for i to m do c[i,0] 0 for j 0 to n do c[0,j] 0 for i to m do for j to n do if x i = y j then c[i,j] c[i-,j-] + b[i,j] else if c[i-,j] ' c[i,j-] then c[i,j] c[i-,j] b[i,j] else c[i,j] c[i,j-] b[i,j] return c and b b[i,j] è un puntatore al sottoproblema usato per risolvere la LCS di X i e Y j I valori b[i,j] sono utili per calcolare la sottosequenza di lunghezza massima Il valore c[m,n] è la lunghezza della LCS di X e Y. Complessità O(mn) Longest Common Subsequence: costruzione di una LCS Riepilogo Cap., Dynamic Programming PRINT-LCS (b, X, i, j) if i = 0 or j = 0 then return if b[i, j] = then PRINT-LCS(b, X, i-, j-) print x i else if b[i, j] = then PRINT-LCS(b, X, i-, j) else PRINT-LCS(b, X, i, j-) Chiamata iniziale: PRINT-LCS (b, X, i, j) Quando b[i, j] =, la LCS viene estesa di un carattere. Running Time: O(m + n ). Weighted Interval Scheduling. Principles of Dynamic Programming. Segmented Least Squares. Knapsack Problem. RNA Secondary Structure. Sequence Alignment. Sequence Alignment in Linear Space (no).8 Shortest Paths in a raph.9 Shortest Paths and Distance Vector Protocols (no).0 Negative Cycles in a raph (no) Esercizio: Longest Common Subsequence