Page 1
1© Alberto Montresor
Algoritmi e Strutture DatiCapitolo 13 - Programmazione dinamica
Alberto MontresorUniversità di Trento
This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/2.5/ or send a letter to Creative Commons, 543 Howard Street, 5th Floor, San Francisco, California, 94105, USA.
Page 2
2© Alberto Montresor
Programmazione dinamica
✦Divide-et-impera
✦Tecnica ricorsiva
✦Approccio top-down (problemi divisi in sottoproblemi)
✦Vantaggioso solo quando i sottoproblemi sono indipendenti
✦Altrimenti, gli stessi sottoproblemi possono venire risolti più volte
✦Programmazione dinamica
✦Tecnica iterativa
✦Approccio bottom-up
✦Vantaggiosa quando ci sono sottoproblemi in comune
✦Esempio semplice: il triangolo di Tartaglia
Page 3
3© Alberto Montresor
Coefficienti binomiali
✦Coefficienti binomiali
✦Il numero di modi di scegliere k oggetti da un insieme di n oggetti
✦I coefficienti di un’equazione di grado n
Page 4
4© Alberto Montresor
Triangolo di Tartaglia
✦Versione ricorsiva
✦Deriva direttamente dalla definizione
✦Domanda
✦Complessità?
Page 5
5© Alberto Montresor
Triangolo di Tartaglia
✦Versione iterativa
✦Basata su programmazione dinamica
✦Domanda
✦Complessità?
Page 6
6© Alberto Montresor
Quando applicare la programmazione dinamica?Quando applicare la programmazione dinamica?
✦Sottostruttura ottima
✦E' possibile combinare le soluzioni dei sottoproblemi per trovare la soluzione di un problema più grande
✦PS: In tempo polinomiale!
✦Le decisioni prese per risolvere un problema rimangono valide quando esso diviene un sottoproblema di un problema più grande
✦Sottoproblemi ripetuti
✦Un sottoproblema può occorrere più volte
✦Spazio dei sottoproblemi
✦Deve essere polinomiale
Page 7
7© Alberto Montresor
Programmazione dinamica
✦Caratterizzare la struttura di una soluzione ottima
✦Definire ricorsivamente il valore di una soluzione ottima
✦La soluzione ottima ad un problema contiene le soluzioni ottime ai sottoproblemi
✦Calcolare il valore di una soluzione ottima “bottom-up” (cioè calcolando prima le soluzioni ai casi più semplici)
✦Si usa una tabella per memorizzare le soluzioni dei sottoproblemi
✦Evitare di ripetere il lavoro più volte, utilizzando la tabella
✦Costruire la (una) soluzione ottima.
Page 8
8© Alberto Montresor
Catena di moltiplicazione di matrici
✦Problema:
✦Data una sequenza di matrici A1, A2, A3, …, An, compatibili 2 a 2 al prodotto, vogliamo calcolare il loro prodotto.
✦Cosa vogliamo ottimizzare
✦La moltiplicazione di matrici si basa sulla moltiplicazione scalare come operazione elementare.
✦Vogliamo calcolare il prodotto impiegando il numero minore possibile di moltiplicazioni
✦Attenzione:
✦Il prodotto di matrici non è commutativo...
✦...ma è associativo: (A1 ⋅ A2) ⋅ A3 = A1 (⋅ A2 ⋅ A3)
Page 9
9© Alberto Montresor
Catena di moltiplicazione tra matriciCatena di moltiplicazione tra matrici
✦3 matrici: A B C100x1 1x100 100x1
# Moltiplicazioni Memoria
(A ⋅ B )((A ⋅ B ) ⋅ C )
100×1×100 = 10000100×100×1 = 10000 20000
10000 10010100
(B ⋅ C)(A (⋅ B ⋅ C))
1×100×1 = 100100×1×1 = 100 200
1 100 101
Page 10
10
© Alberto Montresor
Catena di moltiplicazione tra matriciCatena di moltiplicazione tra matrici
✦4 matrici: A B C D
50x10 10x40 40x3030x5
((( A ⋅ B ) ⋅ C ) ⋅ D ) : 87500 moltiplicazioni
(( A ⋅ ( B ⋅ C )) ⋅ D ) : 34500 moltiplicazioni
(( A ⋅ B ) ⋅ ( C ⋅ D )) : 36000 moltiplicazioni
( A ⋅ (( B ⋅ C ) ⋅ D )) : 16000 moltiplicazioni
( A ⋅ ( B ⋅ ( C ⋅ D ))) : 10500 moltiplicazioni
((( A ⋅ B ) ⋅ C ) ⋅ D ) : 87500
( A ⋅ B ) 50×10×40 = 20000(( A ⋅ B ) ⋅ C ) 50×40×30 = 60000(( A ⋅ B ) ⋅ C ) ⋅ D 50×30× 5 = 7500
87500
Page 11
11
© Alberto Montresor
Applicare la programmazione dinamica
✦Le fasi principali:
✦Caratterizzare la struttura di una soluzione ottima
✦Definire ricorsivamente il valore di una soluzione ottima
✦Calcolare il valore di una soluzione ottima “bottom-up” (dal basso verso l’alto)
✦Costruzione di una soluzione ottima
✦Nei lucidi successivi:
✦Vediamo ora una ad una le quattro fasi del processo di sviluppo applicate al problema della parentesizzazione ottima
Page 12
12
© Alberto Montresor
ParentesizzazioneParentesizzazione
✦Definizione: Una parentesizzazione Pi,j del prodotto Ai · Ai+1 · · · Aj consiste
✦nella matrice Ai, se i = j;
✦nel prodotto di due parentesizzazioni (Pi,k · Pk+1,j), altrimenti.
✦Esempio:
✦(A1·(A2·A3 )) · (A4·(A5·A6 )) →k=3
✦“Ultima moltiplicazione”
(A1·(A
2·A
3 ))·(A
4·(A
5·A
6 ))
(A1·(A
2·A
3 )) (A
4·(A
5·A
6 ))
A1
(A2·A
3 ) A
4(A
5·A
6 )
A2
A3
A5
A6
Page 13
13
© Alberto Montresor
Parentesizzazione ottimaParentesizzazione ottima
✦Parentesizzazione ottima
✦Determinare il numero di moltiplicazioni scalari necessari per i prodotti tra le matrici in ogni parentesizzazione
✦Scegliere una delle parentesizzazioni che richiedono il numero minimo di moltiplicazioni
✦Motivazione:
✦Vale la pena di spendere un po' di tempo per cercare la parentesizzazione migliore, per risparmiare tempo dopo
✦Domanda
✦Quante sono le parentesizzazioni possibili?✦n=3 → 2, n=4 → 5, n=5 → ???
Page 14
14
© Alberto Montresor
Parentesizzazione ottimaParentesizzazione ottima
✦Definiamo una relazione di ricorrenza
✦P(n): numero di parentesizzazioni per n matrici A1 · A2 · A3 ···An
✦L'ultima moltiplicazione può occorrere in n-1 posizioni diverse
✦Fissato l'indice k dell'ultima moltiplicazione, abbiamo✦P(k) parentesizzazioni per A1 · A2 · A3 ··· Ak
✦P(n-k) parentesizzazioni per Ak+1 · Ak+2 ··· An
4862143042913242145211P(n)
10987654321n
Page 15
15
© Alberto Montresor
Parentesizzazione ottimaParentesizzazione ottima
✦Equazione di ricorrenza:
✦Soluzione: n-1-esimo “numero catalano”
✦Domanda: Più semplicemente, dimostrare che P(n) = Ω(2n)
✦Conseguenza: la “forza bruta” (tentare tutte le possibili parentesizzazioni) non funziona
Page 16
16
© Alberto Montresor
Definizioni
✦Denoteremo nel seguito con:
✦A1 · A2 · A3 ··· An il prodotto di n matrici da ottimizzare
✦ci-1 il numero di righe della matrice Ai
✦ci il numero di colonne della matrice Ai
✦A[i..j] il prodotto Ai · Ai+1 ··· Aj
✦P[i..j] una parentesizzazione di A[i..j](non necessariamente ottima)
Page 17
17
© Alberto Montresor
Struttura di una parentesizzazione ottimaStruttura di una parentesizzazione ottima
✦Sia A[i..j] = Ai · Ai+1 ··· Aj una sottosequenza del prodotto di matrici
✦Si consideri una parentesizzazione ottima P[i..j] di A[i..j]
✦Esiste una “ultima moltiplicazione”: in altre parole, esiste un indice k tale che P[i..j] = P[i..k] · P[k+1..j]
✦Domanda:
✦Quali sono le caratteristiche delle due sotto-parti P[i..k] e P[k+1..j] ?
( P[i..k] ) · ( P[k+1..j] )
P[i..k] P[k+1..j]
? ?
Page 18
18
© Alberto Montresor
Struttura di una parentesizzazione ottimaStruttura di una parentesizzazione ottima
✦Teorema (sottostruttura ottima)
✦Se P[i..j] = P[i..k] · P[k+1..j] è una parentesizzazione ottima del prodotto A[i..j], allora P[i..k] e P[k+1..j] sono parentesizzazioni ottime dei prodotti A[i..k] e A[k+1..j], rispettivamente.
✦Dimostrazione
✦Ragionamento per assurdo
✦Supponiamo esista un parentesizzazione ottima P'[i..k] di A[i..k] con costo inferiore a P[i..k]
✦Allora, P'[i..k] · P[k+1..j] sarebbe una parentesizzazione di A[i..j] con costo inferiore a P[i..j], assurdo.
Page 19
19
© Alberto Montresor
Struttura di una parentesizzazione ottima
✦In altre parole:
✦Il teorema afferma che esiste una sottostruttura ottima:
Ogni soluzione ottima al problema della parentesizzazione contiene al suo interno le soluzioni ottime dei due sottoproblemi
✦Programmazione dinamica:
✦L'esistenza di sottostrutture ottime è una delle caratteristiche da cercare per decidere se la programmazione dinamica è applicabile
✦Prossima fase:
✦Definire ricorsivamente il costo di una soluzione ricorsiva
Page 20
20
© Alberto Montresor
Definire ricorsivamente il valore di una soluzione ottima Definire ricorsivamente il valore di una soluzione ottima
✦Definizione: sia M[i,j] il numero minimo di prodotti scalari richiesti per calcolare il prodotto A[i,j]
✦Come calcolare M[i,j]?
✦Caso base: i=j . Allora, M[i,j] = 0
✦Passo ricorsivo: i < j. Esiste una parentesizzazione ottima P[i..j] = P[i..k] · P[k+1..j]; sfruttiamo la ricorsione:
M[i,j] = M[i,k] + M[k+1,j] + ci-1 · ck · cj
Prodotti per P[i..k]
Prodotti per P[k+1..j]
Prodotto di una coppia di matrici: n. righe: prima matrice n. colonne: ultima matrice
Page 21
21
© Alberto Montresor
Definire ricorsivamente il valore di una soluzione ottima
✦Ma qual è il valore di k?
✦Non lo conosciamo....
✦... ma possiamo provarli tutti!
✦k può assumere valori fra i e j-1
✦La formula finale:
✦M[i,j] = mini ≤ k < j { M[i,k] + M[k+1, j] + ci-1 · ck · cj }
Page 22
22
© Alberto Montresor
EsempioEsempio
6
5
4
3
2
1
654321L R
-----6
----5
---4
--3
-2
1
654321L R
06
05
04
03
02
01
654321
M[1,2] = min1 ≤ k < 2 { M[1,k] + M[k+1,2] + c0ckc2 }= M[1,1] + M[2,2] + c0c1c2
= c0c1c2
i \ j
Page 23
23
© Alberto Montresor
EsempioEsempio
6
5
4
3
2
1
654321L R
-----6
----5
---4
--3
-2
1
654321L R
06
05
04
03
02
01
654321L R
M[2,4] = min2≤k<4{ M[2,k] + M[k+1,4] + c1ckc4 }= min { M[2,2] + M[3,4] + c1c2c4,
M[2,3] + M[4,4] + c1c3c4 }
i \ j
Page 24
24
© Alberto Montresor
EsempioEsempio
6
5
4
3
2
1
654321L R
-----6
----5
---4
--3
-2
1
654321L R
06
05
04
03
02
01
654321L R
M[2,5] = min2≤k<5{ M[2,k] + M[k+1,5] + c1ckc5 }= min { M[2,2] + M[3,5] + c1c2c5,
M[2,3] + M[4,5] + c1c3c5, M[2,4] + M[5,5] + c1c4c5 }
i \ j
Page 25
25
© Alberto Montresor
EsempioEsempio
6
5
4
3
2
1
654321L R
-----6
----5
---4
--3
-2
1
654321L R
06
05
04
03
02
01
654321L R
M[1,5] = min1≤k<5{ M[1,k] + M[k+1,5] + c0ckc5 }= min { M[1,1] + M[2,5] + c0c1c5 ,
M[1,2] + M[3,5] + c0c2c5 , M[1,3] + M[4,5] + c0c3c5 , M[1,4] + M[5,5] + c0c4c5 }
i \ j
Page 26
26
© Alberto Montresor
EsempioEsempio
6
5
4
3
2
1
654321L R
-----6
----5
---4
--3
-2
1
654321L R
06
05
04
03
02
01
654321L R
M[1,6] = min1≤k<6{ M[1,k] + M[k+1,6] + c0ckc6 }= min { M[1,1] + M[2,6] + c0c1c6 ,
M[1,2] + M[3,6] + c0c2c6 , M[1,3] + M[4,6] + c0c3c6 , M[1,4] + M[5,6] + c0c4c6 , M[1,5] + M[6,6] + c0c5c6 }
i \ j
Page 27
27
© Alberto Montresor
Calcolo “bottom-up” del valore della soluzione
✦Passiamo ora al terzo passo della programmazione dinamica:
✦“calcolare in modo bottom-up il valore della soluzione ottima”
✦Ma la definizione ricorsiva di M[i,j] suggerisce di utilizzare un approccio ricorsivo top-down per risolvere il problema:
✦Lanciamo il problema sulla sequenza completa [1,n]
✦Il meccanismo ricorsivo individua i sottoproblemi da risolvere
✦Proviamo... male non fa ;-)
✦Input: un array c[0..n] con le dimensioni delle matrici,✦c[0] è il numero di righe della prima matrice✦c[i] è il numero di colonne della matrice Ai
Page 28
28
© Alberto Montresor
Soluzione ricorsiva top-downSoluzione ricorsiva top-down
Domanda: Complessità risultante?
Page 29
29
© Alberto Montresor
Critica all'approccio top-downCritica all'approccio top-down
✦Alcune riflessioni
✦La soluzione ricorsiva top-down è Ω(2n)
✦Non è poi migliore dell'approccio basato su forza bruta!
✦Qual è il problema?
✦Il problema principale è che molti problemi vengono risolti più volte
1…4
1…1 2…4 1…2 3…4 1…3 4…4
1…1 2…22…2 3…4 2…3 4…4 3…3 4…4 1…1 2…3 1…2 3…3
3…3 4…4 2…2 3…3 2…2 3…3 1…1 2…2
Page 30
30
© Alberto Montresor
Calcolare la soluzione ottima in modo bottom-upCalcolare la soluzione ottima in modo bottom-up
✦E' interessante notare che il numero di possibili problemi è molto inferiore a 2n
✦uno per ogni scelta di i e j (con 1 ≤ i ≤ j ≤ n):
✦Ogni sottoproblema
✦È risolvibile utilizzando le soluzioni dei sottoproblemi che sono state eventualmente già calcolate e memorizzate nell'array
✦Idea chiave della programmazione dinamica:
✦Mai calcolare più di una volta la soluzione ad un sottoproblema
Sottoproblemicon i ≠ j Sottoproblemi
con i = j
Page 31
31
© Alberto Montresor
Calcolare la soluzione ottima in modo bottom-upCalcolare la soluzione ottima in modo bottom-up
✦L’algoritmo parentesizzazione()
✦prende in ingresso un array c[0..n] con le dimensioni delle matrici✦c[0] è il numero di righe della A1
✦c[i] è ✦il numero di righe della matrice Ai+1
✦il numero di colonne della matrice Ai
✦utilizza (e ritorna) due matrici n·n ausiliarie:✦M[i,j] che contiene i costi minimi dei sottoproblemi A[i..j] ✦S[i,j] che contiene il valore di k che minimizza il costo per il sottoproblema
Page 32
32
© Alberto Montresor
Algoritmo
h varia sulle diagonali sopraquella principale
i e j assumono i valori dellecelle nella diagonale h
Calcola tutti i possibili valori e conserva solo il più piccolo 06
0504
0302
01654321L
Page 33
33
© Alberto Montresor
0-----6
0----5
0---4
0--3
0-2
01
654321L R
06
9005
3004
2403
6402
22401
654321L R
M[1,4] = min1 ≤ k ≤ 3{ M[1,k] + M[k+1,4] + c0ckc4 }= min { M[1,1] + M[2,4] + c0c1c4,
M[1,2] + M[3,4] + c0c2c4,M[1,3] + M[4,4] + c0c3c4 }
= min { 0 + 112 + 7 * 8 * 3,224 + 24 + 7 * 4 * 3,176 + 0 + 7 * 2 * 3 }
= min { 280, 332, 218 } = 218
06
9005
903004
702403
1126402
17622401
654321L R
06
9005
903004
138702403
1741126402
21817622401
654321L R
06
9005
903004
138702403
2501741126402
35027621817622401
654321L R
66
55
34
23
42
81
70
cii
06
9005
903004
138702403
2501741126402
27621817622401
654321L R
06
05
304
7003
6402
17622401
65321i
M[ ]
i \ j
Page 34
34
© Alberto Montresor
M[1,4] = min1 ≤ k ≤ 3{ M[1,k] + M[k+1,4] + c0ckc4 }= min { M[1,1] + M[2,4] + c0c1c4,
M[1,2] + M[3,4] + c0c2c4,M[1,3] + M[4,4] + c0c3c4 }
= min { 0 + 112 + 7 * 8 * 3,224 + 24 + 7 * 4 * 3,176 + 0 + 7 * 2 * 3 }
= min { 280, 332, 218 } = 218
66
55
34
23
42
81
70
cii
S[ ]
06
505
5404
3303
3202
1101
654321L R
6
5
3
2
3 1
L R
3
33
3 3
i \ j
Page 35
35
© Alberto Montresor
Calcolare la soluzione ottima in modo bottom-upCalcolare la soluzione ottima in modo bottom-up
✦Considerazioni sull'algoritmo
✦Costo computazionale: O(n3)
✦Nota
✦Lo scopo della terza fase era “calcolare in modo bottom-up il valore della soluzione ottima”
✦Questo valore si trova in M[1,n]
✦Per alcuni problemi
✦E' anche necessario mostrare la soluzione trovata
✦Per questo motivo registriamo informazioni sulla soluzionementre procediamo in maniera bottom-up
Page 36
36
© Alberto Montresor
Costruire una soluzione ottimaCostruire una soluzione ottima
✦Possiamo definire un algoritmo che costruisce la soluzione a partire dall'informazione calcolata da parentesizzazione().
✦La matrice S ci permette di determinare il modo migliore di moltiplicare le matrici.
✦S[i,j]=k contiene infatti il valore k su cui dobbiamo spezzare il prodotto A[i..j]
✦Ci dice cioè che per calcolare A[i..j] dobbiamo prima calcolare A[i..k] e A[k+1..j] e poi moltiplicarle tra loro.
✦Ma questo è un processo facilmente realizzabile tramite un algoritmo ricorsivo
Page 37
37
© Alberto Montresor
Costruire una soluzione ottimaCostruire una soluzione ottima
Page 38
38
© Alberto Montresor
Costruire una soluzione ottimaCostruire una soluzione ottima
Page 39
39
© Alberto Montresor
Esempio di esecuzioneEsempio di esecuzione
06
505
5404
33303
333202
3331101
654321L R
A1…6 = A1…k×Ak+1…6
= A1…3×A4…6
A1…3 = A1…k×Ak+1…3
=A1×A2…3
A4…6 = A4…k×Ak+1…6
=A4..5×A6
A2…3 = A2…k×Ak+1…3
= A2×A3
A4…5 = A4…k×Ak+1…5
=A4×A5
A1…6 = ( ( A1 (A2A3) )( (A4A5 ) A6) )
S[ ]
i \ j
Page 40
40
© Alberto Montresor
Numeri di FibonacciNumeri di Fibonacci
✦Definiti ricorsivamente
✦F(0) = F(1) = 1
✦F(n) = F(n-2)+F(n-1)
✦Un po' di storia
✦Leonardo di Pisa, detto Fibonacci
✦Utilizzati per descrivere la crescita di una popolazione di conigli (!)
✦In natura:
✦Pigne, conchiglie, parte centrale dei girasoli, etc.
✦In informatica:
✦Alberi AVL minimi, Heap di Fibonacci, etc.
Page 41
41
© Alberto Montresor
Implementazione ricorsivaImplementazione ricorsiva
✦Complessità computazionale
✦Soluzione
✦T(n) = O(2n)
Page 42
42
© Alberto Montresor
Implementazione iterativaImplementazione iterativa
21
7
13
6
8
5
53211f [ ]
43210n
✦Complessità
✦In tempo: O(n)
✦In spazio: O(n)✦Array di n elementi
Page 43
43
© Alberto Montresor
Implementazione iterativa - risparmio memoriaImplementazione iterativa - risparmio memoria
21
7
13
6
8
5
53211F2
43210n
F1
F0
138532111
853211--
✦Complessità
✦In tempo: O(n)
✦In spazio: O(1)✦3 variabili
Page 44
44
© Alberto Montresor
Zaino
✦Input
✦Un intero positivo C - la capacità dello zaino
✦n oggetti, tali che l’oggetto i-esimo è caratterizzato da: ✦un profitto pi e ✦un volume vi , entrambi interi positivi
✦Problema
✦trovare un sottoinsieme S di {1, . . . , n} di oggetti tale che il volume totale non superi la capacità massima e il profitto totale sia massimo
Page 45
45
© Alberto Montresor
Zaino
✦Caratterizzazione del problema
✦P(i, c) è il sottoproblema dato dai primi i oggetti da inserire in uno zaino con capacità c
✦Il problema originale corrisponde a P(n, C)
✦Teorema - sottostruttura ottima
✦Sia S(i, c) una soluzione ottima per il problema P(i, c)
✦Possono darsi due casi:✦Se i ∈ S(i, c), allora S(i, c)-{i} è una soluzione ottima per il sottoproblema P(i-1, c-vi )✦Se i ∉ S(i, c), allora S(i, c) è una soluzione ottima per il sottoproblema P(i−1, c)
✦Dimostrazione
✦per assurdo
Page 46
46
© Alberto Montresor
Zaino
✦Tabella per programmazione dinamica
✦D[i, c] contiene il profitto massimo ottenibile per il problema P(i,c)
✦Alcune considerazioni
✦Costo di un algoritmo di programmazione dinamica bottom-up: O(nC)
✦Non è detto che tutti i problemi debbano essere risolti
Page 47
47
© Alberto Montresor
Memoization
✦Memoization (annotazione)
✦Tecnica che fonde l'approccio di memorizzazione della programmazione dinamica con l'approccio top-down di divide-et-impera
✦Quando un sottoproblema viene risolto per la prima volta, viene memorizzato in una tabella
✦ogni volta che si deve risolvere un sotto-problema, si controlla nella tabella se è già stato risolto precedentemente
✦SI: si usa il risultato della tabella✦NO: si calcola il risultato e lo si memorizza
✦In tal modo, ogni sottoproblema viene calcolato una sola volta e memorizzato come nella versione bottom-up
Page 48
48
© Alberto Montresor
Zaino “annotato”
✦Note sulla soluzione
✦⏊ è un valore speciale per indicare che un certo problema non è stato risolto
✦Gli elementi della tabella D sono inizializzati con il valore ⏊
Page 49
49
© Alberto Montresor
Discussione su memoization
✦Caso pessimo
✦Nel caso pessimo, è comunque O(nC)
✦Quando si verifica?
✦Inizializzazione
✦E’ necessario inizializzare D - costo O(nC)
✦Se il costo dell’inizializzazione è asintoticamente inferiore al costo di ricombinare i risultati, si ottiene un guadagno
✦Altrimenti: è possibile utilizzare una tabella hash
✦Complessità pseudo-polinomiale
✦La complessità O(nC) è polinomiale nella dimensione dell’input?
Page 50
50
© Alberto Montresor
Bioinformatica
✦DNA
✦Una stringa di molecole chiamate basi
✦Solo quattro basi: Adenina, Citosina, Guanina, Timina
✦Esempi
✦Due esempi di DNA: AAAATTGA, TAACGATAG
✦Date due sequenze, è lecito chiedersi quanto siano “simili”
✦Una è sottostringa dell'altra?
✦Distanza di editing: costo necessario per trasformare una nell'altra
✦La più lunga sottosequenza (anche non contigua) comune ad entrambe
Page 51
51
© Alberto Montresor
Caratterizzazione del problema
✦Definizione
✦Una sequenza T è una sotto-sequenza di P se T è ottenuta da P rimuovendo uno o più elementi
✦Alternativamente: T è definito come il sottoinsieme degli indici l'insieme di elementi di P che compaiono anche in T
✦Gli elementi rimanenti devono comparire nello stesso ordine, anche se non devono essere necessariamente contigui in P
✦Esempio
✦P = “AAAATTGA” , T = “AAATA”
✦Nota
✦La sequenza nulla è una sotto-sequenza di ogni sequenza
Page 52
52
© Alberto Montresor
Caratterizzazione del problema
✦Definizione:
✦Date due sequenze P e T, una sequenza Z è una sottosequenza comune di P e T se Z è sottosequenza sia di P che di T
✦Scriviamo Z ∈ CS(P, T)
✦“Common Subsequence”, o CS
✦Definizione:
✦Date due sequenze P e T, una sequenza è una sottosequenza comune massimale di P e T, se Z ∈ CS(P, T) e non esiste una sequenza W ∈ CS(P, T) tale che |W| > |Z|
✦Scriviamo Z ∈ LCS(P, T)
✦“Longest Common Subsequence”, o LCS
Page 53
53
© Alberto Montresor
Caratterizzazione del problema
✦Problema LCS
✦Input: due sequenze di simboli, P e T
✦Output: Trovare la più lunga sottosequenza Z comune a P e T
✦Esempio
✦P = “AAAATTGA”
✦T = “TAACGATA”
✦LCS(P,T) = ????
✦Prima di provare con la programmazione dinamica, proviamo di “forza bruta”...
Page 54
54
© Alberto Montresor
Risoluzione tramite enumerazioneRisoluzione tramite enumerazione
Domanda: Quante sono le sotto-sequenze di P?
Page 55
55
© Alberto Montresor
Caratterizzazione della soluzione ottimaCaratterizzazione della soluzione ottima
✦Data una sequenza P=(p1, …, pn):
✦denoteremo con P(i) l’i-esimo prefisso di P, cioè la sotto-sequenza ( p1, … , pi )
✦Esempio:
✦P = ABDCCAABD
✦P(0) denota la sotto-sequenza nulla
✦P(3) = ABD
✦P(6) = ABDCCA
Page 56
56
© Alberto Montresor
Caratterizzazione della soluzione ottimaCaratterizzazione della soluzione ottima
✦Teorema (Sottostruttura ottima)
✦Date le due sequenze P=(p1,…, pm) e T=(t1, …, tn), sia Z=(z1,…,zk ) una LCS di P e T
✦ pm= tn → zk = pm = tn e Z(k-1) ∈ LCS(
P(m-1), T(n-1) )✦ pm ≠ tn e zk ≠ pm → Z ∈ LCS( P(m-1), T )✦ pm ≠ tn e zk ≠ tn → Z ∈ LCS( P, T(n-1) )
✦Dimostrazione
Page 57
57
© Alberto Montresor
Dimostrazione
✦Punto 1
✦Supponiamo per assurdo che zk ≠ pm = tn ✦Si consideri W=Zpm. Allora W ∈ CS(P,T) e | W | > | Z |, assurdo✦Quindi zk = pm = tn
✦Supponiamo per assurdo che Z(k-1) ∉ LCS( P(m-1), T(n-1) )✦Allora esiste W ∈ LCS( P(m-1), T(n-1) ) tale che |W| > |Z(k-1)|✦Quindi Wpm ∈ CS(P,T) e |Wpm| > |Z|, assurdo
P[1,…,m-1]
T[1,…,n-1]
Z[1,…,k-1]
aa
a
P[1,…,m]T[1,…,n]
Z[1,…,k]
Page 58
58
© Alberto Montresor
Dimostrazione
✦Punto 2 (Punto 3 simmetrico)
✦Se zk ≠ pm, allora Z ∈ CS(P(m-1), T)
✦Per assurdo ipotizziamo che Z ∉ LCS(P(m-1), T)allora esiste W ∈ LCS(P(m-1), T) tale che: | W | > | Z |
✦Allora è anche vero che W ∈ LCS(P, T), contraddicendo l'ipotesi
b
P[1,…,m]T[1,…,n]
a
?Z[1,…,k]
P[1,…,m-1]T[1,…,n] b
?Z[1,…,k]
Page 59
59
© Alberto Montresor
Cosa ci dice il teorema?
✦Se pm = tn, dobbiamo risolvere un sottoproblema
✦LCS( P(m-1), T(n-1) )
✦La definizione ricorsiva è la seguente:✦LCS(P,T) = LCS( P(m-1), T(n-1) ) pm
✦Se pm ≠ tn, dobbiamo risolvere due sottoproblemi
✦LCS( P(m-1), T ) LCS( P, T(n-1) )
✦A questo punto, dobbiamo scegliere la LCS più lunga fra le 2
✦La definizione ricorsiva è la seguente:✦LCS(P,T) = longest( LCS( P(m-1), T ) , LCS( P, T(n-1) ) )
Page 60
60
© Alberto Montresor
LCS basato su programmazione dinamicaLCS basato su programmazione dinamica
✦Definiamo una tabella per memorizzare la lunghezza dei vari sottoproblemi di LCS:
✦D[0 ... m, 0 ... n] → tabella di (m+1) · (n+1) elementi, dove |P| = m, |T| = n
✦D[i,j] → lunghezza della LCS di P(i) e T(j)
✦Goal finale:
✦Calcolare D[m,n] → lunghezza della LCS di P e T
✦Formulazione ricorsiva
Page 61
61
© Alberto Montresor
LCS basato su programmazione dinamicaLCS basato su programmazione dinamica
✦Definiamo una tabella per memorizzare informazioni necessarie ad ottenere la stringa finale
✦B[0 ... m, 0 ... n] → tabella di (m+1) · (n+1) elementi, dove |P| = m, |T| = n
✦B[i,j] → “puntatore” alla entry della tabella stessa che identifica il sottoproblema ottimo scelto durante il calcolo del valore D[i,j]
✦Valori possibili:
➘deriva da i-1,j-1 ↓ deriva da i-1,j→deriva da i,j-1
Page 62
62
© Alberto Montresor
0 1 2 3 4 5 6
A T B C B D
0 0 0 0 0 0 0 0
1 T 0 ↓0 ➘ 1 →1 →1 →1 →1
2 A 0 ➘ 1 ↓ 1 ↓ 1 ↓ 1 ↓ 1 ↓ 1
3 C 0 ↓ 1 ↓ 1 ↓ 1 ➘ 2 →2 →2
4 C 0 ↓ 1 ↓ 1 ↓ 1 ➘ 2 ↓ 2 →2
5 B 0 ↓ 1 ↓ 1 ➘ 2 ↓ 2 ➘ 3 →3
6 T 0 ↓ 1 ➘ 2 ↓ 2 ↓ 2 ↓ 3 ↓ 3
i
j
➘deriva da i-1,j-1 ↓ deriva da i-1,j→deriva da i,j-1
• TACCBT• ATBCBD
Page 63
© Alberto Montresor
0 1 2 3 4 5 6
B E B E D E
0 0 0 0 0 0 0 0
1 A 0 ↓ 0 ↓ 0 ↓ 0 ↓ 0 ↓ 0 ↓ 0
2 B 0 ➘1 →1 ➘ 1 →1 →1 →1
3 D 0 ↓ 1 ↓ 1 ↓ 1 ↓ 1 ➘2 →2
4 D 0 ↓ 1 ↓ 1 ↓ 1 ↓ 1 ➘ 2 ↓ 2
5 B 0 ➘ 1 ↓ 1 ➘2 →2 ↓ 2 ↓ 2
6 E 0 ↓ 1 ➘2 ↓ 2 ➘ 3 →3 ➘ 3
i
j
➘deriva da i-1,j-1 ↓ deriva da i-1,j→deriva da i,j-1
• ABDDBE• BEBEDE
Page 64
64
© Alberto Montresor
Calcolo del valore della soluzione ottimaCalcolo del valore della soluzione ottima
Page 65
© Alberto Montresor
0 1 2 3 4 5 6
B E B E D E
0 0 0 0 0 0 0 0
1 A 0 ↓ 0 ↓ 0 ↓ 0 ↓ 0 ↓ 0 ↓ 0
2 B 0 ➘1 →1 ➘ 1 →1 →1 →1
3 D 0 ↓ 1 ↓ 1 ↓ 1 ↓ 1 ➘2 →2
4 D 0 ↓ 1 ↓ 1 ↓ 1 ↓ 1 ➘ 2 ↓ 2
5 B 0 ➘ 1 ↓ 1 ➘2 →2 ↓ 2 ↓ 2
6 E 0 ↓ 1 ➘2 ↓ 2 ➘ 3 →3 ➘ 3
i
j
➘deriva da i-1,j-1 ↓ deriva da i-1,j→deriva da i,j-1
• ABDDBE• BEBEDE
Page 66
66
© Alberto Montresor
0 1 2 3 4 5 6
A T B C B D
0 0 0 0 0 0 0 0
1 T 0 ↓0 ➘ 1 →1 →1 →1 →1
2 A 0 ➘ 1 ↓ 1 ↓ 1 ↓ 1 ↓ 1 ↓ 1
3 C 0 ↓ 1 ↓ 1 ↓ 1 ➘ 2 →2 →2
4 C 0 ↓ 1 ↓ 1 ↓ 1 ➘ 2 ↓ 2 →2
5 B 0 ↓ 1 ↓ 1 ➘ 2 ↓ 2 ➘ 3 →3
6 T 0 ↓ 1 ➘ 2 ↓ 2 ↓ 2 ↓ 3 ↓ 3
i
j
➘deriva da i-1,j-1 ↓ deriva da i-1,j→deriva da i,j-1
• TACCBT• ATBCBD
Page 67
67
© Alberto Montresor
Alcune ottimizzazioni
✦La matrice B può essere eliminata:
✦Il valore di D[i,j] dipende solo dai valori D[i-1,j-1], D[i,j-1] e D[i-1,j].
✦In tempo costante si può quindi determinare quale di questi tre è stato usato, e perciò quale sia il tipo di freccia
✦Se ci serve solo calcolare la lunghezza della LCS, possiamo ridurre la tabella D[i,j] a due sole righe di lunghezza min{ n , m }
✦Ad ogni istante (cioè per ogni coppia i,j), ci servono i valori D[i-1,j-1], D[i,j-1] e D[i-1,j]
✦Esercizio
Page 68
68
© Alberto Montresor
Stampa della soluzione ottimaStampa della soluzione ottima
Costo computazionale
A ogni passo, almeno uno fra i e j viene decrementato: θ(m+n)
Page 69
69
© Alberto Montresor
LCS e diff
✦diff
✦Esamina due file di testo, e ne evidenzia le differenze a livello di riga.
✦Lavorare a livello di riga significa che i confronti fra simboli sono in realtà confronti fra righe, e che n ed m sono il numero di righe dei due file
✦Ottimizzazioni
✦diff è utilizzato soprattutto per codice sorgente; è possibile applicare euristichesulle righe iniziali e finali
✦per distinguire le righe - utilizzo di hash table
Page 70
70
© Alberto Montresor
String matching approssimato
✦Input
✦una stringa P = p1 ··· pm (pattern)
✦una stringa T = t1 ··· tn (testo), con m ≤ n
✦Definizione
✦Un’occorrenza k-approssimata di P in T , con 0 ≤ k ≤ m, è una copia della stringa P nella stringa T in cui sono ammessi k “errori” (o differenze) tra caratteri di P e caratteri di T , del seguente tipo:
✦ i corrispondenti caratteri in P e in T sono diversi (sostituzione) ✦ un carattere in P non è incluso in T (inserimento)✦ un carattere in T non è incluso in P (cancellazione)
✦Problema:
✦Trovare un’occorrenza k-approssimata di P in T per cui k sia minimo.
Page 71
71
© Alberto Montresor
Esempio
✦Input
✦questoèunoscempio
✦unesempio
✦Domanda
✦Qual è il minimo valore k per cui si trova una occorrenza k-approssimata?
✦A partire da dove?
✦Con quali errori?
Page 72
72
© Alberto Montresor
Sottostruttura ottima
✦Definizione
✦Tabella D[0...m, 0...n], i cui elementi D[i,j] contengono il minimo valore k per cui esiste una occorrenza k-approssimata di P(i) in T(j)
✦D[i,j] può essere uguale a
✦D[i-1,j-1], se pi = tj avanza su entrambi i caratteri (uguali)
✦D[i-1,j-1]+1, se pi ≠ tj avanza su entrambi i caratteri (sostituzione)
✦D[i-1,j]+1 avanza sul pattern (inserimento)
✦D[i,j-1]+1 avanza sul testo (cancellazione)
Page 73
73
© Alberto Montresor
Sottostruttura ottima
✦Definizione
✦Tabella D[0...m, 0...n], i cui elementi D[i,j] contengono il minimo valore k per cui esiste una occorrenza k-approssimata di P(i) in T(j)
✦Ricordate che cerchiamo il minimo:
Page 74
74
© Alberto Montresor
Ricostruzione della soluzione finale
✦Si noti che:
✦D[m,j] = k se e solo se c’è un’occorrenza k-approssimata di P in T che termina in tj
✦la soluzione del problema è data dal valore di D[m,j] più piccolo, per 0 ≤ j ≤ n
Page 75
75
© Alberto Montresor
Algoritmo String matching approssimato
Domanda: complessità?
Page 76
76
© Alberto Montresor
String matching approssimato
✦Variante dello string matching approssimato: Distanza di editing (Distanza di Levenshtein)
✦Date due stringhe, vogliamo conoscere il numero minimo di operazioni (sostituzione, inserimento, cancellazione) necessarie per trasformare una nell’altra
✦(o viceversa, visto che inserimento e cancellazione sono simmetriche)
✦Esempio:
✦distanza fra google e yahoo?
✦Algoritmo?
✦Come (e se) dobbiamo modificare le condizioni iniziali?
✦Come (e se) dobbiamo modificare la definizione ricorsiva?
Page 77
77
© Alberto Montresor
Insieme indipendente di intervalli pesati
✦Input
✦Siano dati n intervalli distinti [a1, b1[, ..., [an,bn[ della retta reale, aperti a destra, dove all’intervallo i è associato un peso wi, 1 ≤ i ≤ n.
✦Definizione
✦Due intervalli i e j si dicono digiunti se: bj ≤ ai oppure bi ≤ aj
✦Output:
✦Trovare un insieme indipendente di peso massimo, ovvero un sottoinsieme di intervalli tutti disgiunti tra di loro tale che la somma dei pesi degli intervalli nel sottoinsieme sia la più grande possibile
✦Esempio:
✦Prenotazione di una sala conferenza in un hotel
ai bi
aj bj
Page 78
78
© Alberto Montresor
Pre-elaborazione
✦Per poter applicare la programmazione dinamica, è necessario effettuare una pre-elaborazione
✦Ordiniamo gli intervalli per estremi finali non decrescenti✦b1 ≤ b2 ≤ ≤ ⋅ ⋅ ⋅ bn
✦Per ogni intervallo i, sia pi = j il predecessore di i, dove j < i è il massimo indice tale che [aj , bj [ è disgiunto da [ai , bi [ (se non esiste j, allora pi = 0)
✦Teorema sottostruttura ottima
✦Sia P[i] il sottoproblema dato dai primi i intervalli e sia S[i] una sua soluzione ottima di peso D[i]
✦Se l’intervallo i-esimo non fa parte di tale soluzione, allora deve valere D[i] = D[i − 1], dove si assume D[0] = 0; ✦altrimenti, deve essere D[i] = wi + D[pi]
Page 79
79
© Alberto Montresor
Definizione ricorsiva
✦Definizione ricorsiva del peso di una soluzione ottima
✦D[n] è il problema originario
✦Costo della procedura risultante
✦O(n log n) per l’ordinamento
✦O(n log n) per il calcolo degli indici pi
✦O(n) per il riempimento della tabella
✦O(n) per la ricostruzione della soluzione
✦Esercizio:
✦Scrivere algoritmo per il calcolo degli indici pi
Page 80
80
© Alberto Montresor
Codice