Terzo passo: lunghezza di una LCS LCS-Length(X, Y, m, n) for i = 0 to m c[i, 0] = 0 for j = 1 to n c[0, j] = 0 for j = 1 to n for i = 1 to m if x i == y j c[i, j] = c[i-1, j-1]+1, s[i, j] = elseif c[i-1, j] c[i, j-1] c[i, j] = c[i-1, j], s[i, j] = else c[i, j] = c[i, j-1], s[i, j] = return c,s

Quarto passo Esempio X=ABCBDAB Y=BDCABA i j CDB cscs 1 BAA ABCBDABABCBDAB cscs cscs cscs cscs cscs cscs cscs Y X LCS=....LCS=...A 3 3 LCS=..BA 2 2 LCS=.CBA 1 1 LCS=BCBA 0 cscs

Quarto passo: Stampa della LCS Print-LCS(X, s, i, j) if i > 0 and j > 0 if s[i, j] == Print-LCS(X, s, i-1, j-1) print X[i] elseif s[i, j] == Print-LCS(X, s, i-1, j) else Print-LCS(X, s, i, j-1)

Metodo top-down Esempio X=ABCBDAB Y=BDCABA i j CDB 1 BAA ABCBDABABCBDAB Y X cscs cscs cscs cscs cscs cscs cscs cscs

Triangolazione ottima Una triangolazione di un poligono convesso è una suddivisione del poligono in triangoli ottenuta tracciando delle diagonali che non si intersecano. Vi sono più triangolazioni possibili dello stesso poligono

In questo problema sono dati i vertici q 1,q 2,…,q n di un poligono convesso P presi in ordine antiorario. Ad ogni triangolo T è attribuito un costo c(T). Ad esempio c(T) potrebbe essere la lunghezza del perimetro, la somma delle altezze, il prodotto delle lunghezze dei lati, (larea ?), ecc. Si vuole trovare una triangolazione del poligono P tale che la somma dei costi dei triangoli sia minima.

In quanti modi possiamo suddividere in triangoli un poligono convesso di n vertici? Ogni lato del poligono P appartiene ad un solo triangolo della triangolazione. q1q1 qnqn qkqk T Siano q 1 q k q n i vertici del triangolo T a cui appartiene il lato q 1 q n

Il vertice q k può essere scelto in n-2 modi diversi e i due poligoni hanno rispettivamente n 1 = k ed n 2 = n-k+1 vertici. q1q1 qnqn qkqk P1P1 P2P2 T Il triangolo T suddivide il poligono P nel triangolo T stesso e nei due poligoni P 1 e P 2 di vertici q 1,…,q k e q k,…,q n P 1 quando k = 2 e P 2 quando k = n-1 sono poligoni degeneri, ossia sono un segmento.

Il numero T(n) di triangolazioni possibili di un poligono di n vertici si esprime ricorsivamente come segue E facile verificare che T(n) = P(n-1) dove P(n) sono le parentesizzazioni del prodotto di n matrici. Quindi T(n) cresce esponenzialmente.

Primo passo: struttura di una triangolazione ottima. Supponiamo che una triangolazione ottima suddivida il poligono convesso P di vertici q 1 q 2...q n nel triangolo T di vertici q 1 q k q n e nei due poligoni P 1 e P 2 di vertici q 1 …q k e q k …q n rispettivamente. Le triangolazioni subordinate di P 1 e di P 2 sono triangolazioni ottime. Perché?

Secondo passo: soluzione ricorsiva Se j = i+1 allora P i..j è degenere e c i,j = 0. I sottoproblemi sono le triangolazioni dei poligoni P i..j di vertici q i …q j. Sia c i,j la somma dei costi dei triangoli di una triangolazione ottima di P i..j. Se j > i+1 allora P i..j si può scomporre in un triangolo T di vertici q i q k q j e nei due poligoni P 1 e P 2 di vertici q i …q k e q k …q j con i < k < j

Triangulation-Cost(q, n) for i = 1 to n-1 c[i, i+1] = 0 for j = 3 to n for i = j-2 downto 1 c[i, j] = for k = i+1 to j-1 q = c[i, k]+c[k, j]+c(q i q k q j ) if q < c[i, j] c[i, j] = q s[i, j] = k return c,s Terzo passo: calcolo costo minimo Complessità: O(n 3 )

Print-Triangulation(s, i, j) if j > i+1 k = s[i, j] Print-Triangulation(s, i, k) print triangolo:, i, j, k Print-Triangulation(s, k, j) Quarto passo: Stampa triangolazione Complessità: O(n)

Algoritmi golosi Tecniche di soluzione dei problemi viste finora: Metodo iterativo Divide et impera Programmazione dinamica Nuova tecnica: Algoritmi golosi

Metodo iterativo Soluzione del problema di dimensione n Soluzione del problema di dimensione i Soluzione del problema di dimensione i-1

Problema Sottoproblemi Sottosottoproblemi Sottoproblemi semplici Divide et impera Soluzioni

In un problema di ottimizzazione abbiamo un insieme generalmente molto grande di soluzioni e dobbiamo scegliere tra di esse una soluzione che sia ottima in qualche senso (costo minimo, valore massimo, lunghezza minima, ecc.) Soluzioni possibili Ottime

Possiamo risolvere un problema di questo tipo con una enumerazione esaustiva - si generano tutte le soluzioni possibili, - si calcola il costo di ciascuna di esse - e infine se ne seleziona una di ottima. Purtroppo linsieme di soluzioni è generalmente molto grande (spesso esponenziale nella dimensione dellinput) per cui una enumerazione esaustiva richiede tempo esponenziale.

Molto spesso le soluzioni di un problema di ottimizzazione si possono costruire estendendo o combinando tra loro soluzioni di sottoproblemi. Problema Sottoproblemi Soluzioni Esempio: Problema Torino-Trieste. Sottoproblemi: Torino-Asti, Asti-Trieste; Torino- Novara, Novara-Trieste, ecc.

Abbiamo visto che perché la programmazione dinamica sia vantaggiosa rispetto allenumerazione esaustiva bisogna che siano soddisfatte due condizioni: 1.Esistenza di sottoproblemi ripetuti. 2.Sottostruttura ottima.

Problema Sottoproblemi Sottosottoproblemi Sottoproblemi semplici Sottoproblemi ripetuti Soluzioni Sottoproblema ripetuto

Problema Ott Soluzioni Sottoproblemi Sottosottoproblemi Sottoproblemi semplici Sottostruttura ottima Soluzioni ottime Ott Soluzioni ottime Combinazioni di soluzioni ottime dei sottoproblemi

Problema Ott Soluzioni Sottoproblemi Ott Sottosottoproblemi Ott Sottoproblemi semplici Ott Sottoproblemi ripetuti Programmazione dinamica

Problema Ott Soluzioni Sottoproblemi Ott Sottosottoproblemi Ott Sottoproblemi semplici Ott Algoritmi golosi Scelta golosa

1) ogni volta si fa la scelta che sembra migliore localmente. 2) in questo modo per alcuni problemi si ottiene una soluzione globalmente ottima.

Problema della scelta delle attività Ogni attività a i ha un tempo di inizio s i ed un tempo di fine f i con s i < f i. n attività a 1,...,a n usano la stessa risorsa (es: lezioni da tenere in una stessa aula). a i occupa la risorsa nellintervallo di tempo [s i, f i ). a i ed a j sono compatibili se [s i, f i ) ed [s j, f j ) sono disgiunti. Problema: scegliere il massimo numero di attività compatibili.

Storiella Golosa Personaggi: Pinocchio Lalgoritmo goloso Il grillo parlante Controlla Pinocchio Conosce il futuro La fata turchina

Voglio scegliere il maggior numero possibile di divertimenti. Pinocchio arriva nella Città dei Balocchi e può scegliere i divertimenti che preferisce Ogni divertimento ha unorario di inizio ed una durata Perciò comincio scegliendo il divertimento che inizia per primo!! Così non perdo tempo. Attenzione Pinocchio!!! Se fai così non è detto che tu possa scegliere il maggior numero di divertimenti

Allora scelgo il divertimento che dura di meno!! Così mi rimane più tempo per gli altri. Attenzione Pinocchio!!! Anche così non è detto che tu possa scegliere il maggior numero di divertimenti

Allora scelgo il divertimento che non si sovrappone a troppi altri!! Così me ne rimangono di più tra cui scegliere. Attenzione Pinocchio!!! Anche così non è detto che tu possa scegliere il maggior numero di divertimenti Uffa!! Ma sei proprio un rompiscatole!! Ora riprovo e se non ti va ancora bene ti schiaccio con il martello.

Scelgo il divertimento D che termina per primo!! Così quando ho finito mi rimane più tempo per gli altri. Bene Pinocchio!! In questo modo prendi sicuramente il massimo numero di divertimenti ed io posso dimostrarlo. Mumble…, per dimostrarlo debbo provare che la scelta di quel monello non lo conduce in un vicolo cieco. Ossia deve esistere una soluzione ottima a cui Pinocchio può arrivare dopo aver fatto la scelta (la proprietà della scelta golosa). Ma per questo dovrei conoscere il futuro. Qui mi serve laiuto della fatina. Io conosco una soluzione ottima ma non la mostro a nessuno. So che la fatina conosce una soluzione ottima. Insegnerò alla fatina come modificare la sua soluzione ottima in modo che contenga il divertimentoD.

Io conosco una soluzione ottima ma non la mostro a nessuno. Mumble… se la soluzione della fatina contiene già D non ci sono problemi. Io conosco una soluzione ottima che contiene D. Cara fatina, se la tua soluzione contiene il divertimento D lasciala invariata. Ho scelto il divertimento D che termina per primo!! Così quando ho finito mi rimane più tempo per gli altri. Ora so che la fatina conosce una soluzione ottima che contiene il divertimento D. Primo caso:

Io conosco una soluzione ottima ma non la mostro a nessuno. Mumble…. se la soluzione della fatina non contiene D devo dirgli di mettere D al posto di un altro divertimento. Ho scelto il divertimento D che termina per primo!! Così quando ho finito mi rimane più tempo per gli altri. Mumble…. il primo divertimento nella soluzione della fatina termina dopoD e quindi D è compatibile con i successivi Cara fatina, se la tua soluzione non contiene il divertimento D metti D al posto del primo divertimento. Secondo caso:

D1D1 D2D2 DmDm ………………….. D2D2 DmDm D

Io conosco una nuova soluzione ottima che contiene D. Ho scelto il divertimento D che termina per primo!! Così quando ho finito mi rimane più tempo per gli altri. Ora so che la fatina conosce una soluzione ottima che contiene il divertimento D.

Ho finito tutti i divertimenti scelti finora. Ora scelgo il divertimentoD che termina per primo tra quelli non ancora iniziati. Mumble… devo mostrare che esiste una soluzione ottima che contiene sia D che tutti i divertimenti scelti prima. Io conosco una soluzione ottima che contiene tutti i divertimenti scelti finora da Pinocchio. Insegnerò alla fatina come modificare la sua soluzione ottima in modo che contenga anche D.

Ho finito tutti i divertimenti scelti finora ed ora ho scelto quel divertimento D che terminerà per primo tra quelli non ancora iniziati. Io conosco una soluzione ottima che contiene tutti i divertimenti scelti finora da Pinocchio. Io conosco una soluzione ottima che contiene i divertimenti scelti finora compreso il divertimento D. Mumble… se la soluzione della fatina contiene il divertimento D non ci sono problemi. Cara fatina, se la tua soluzione contiene il divertimento D lasciala invariata. Primo caso:

Mumble… se la soluzione della fatina non contiene D devo metterlo al posto di un altro. Io conosco una soluzione ottima che contiene tutti i divertimenti scelti finora da Pinocchio. Non posso certo metterlo al posto di uno di quelli scelti prima e che so essere tutti contenuti nella soluzione della fatina. Non posso neppure metterlo al posto di uno già iniziato perché questi sono incompatibili con quelli scelti prima. Mumble… Il primo che nella soluzione della fatina segue quelli già scelti deve terminare dopo D. Quindi tutti gli altri sono compatibili con D. Cara fatina, se la tua soluzione non contiene il divertimento D mettilo al posto del primo divertimento che nella tua soluzione segue quelli già scelti da Pinocchio. Secondo caso: Ho finito tutti i divertimenti scelti finora ed ora ho scelto quel divertimento D che terminerà per primo tra quelli non ancora iniziati.

DD1D1 DkDk DmDm ….. D k+2 D1D1 DkDk DmDm ….. D k+1 ….. D k+2 ora attuale

Io conosco una nuova soluzione ottima che contiene i divertimenti scelti finora da Pinocchio compresoD. So che la fatina conosce una soluzione ottima che contiene tutti i divertimenti scelti finora da Pinocchio compreso D. Ho finito tutti i divertimenti scelti finora ed ora ho scelto quel divertimento D che terminerà per primo tra quelli non ancora iniziati.

Io conosco una soluzione ottima che contiene tutti i divertimenti scelti finora da Pinocchio. Ho finito tutti i divertimenti scelti finora ma tutti gli altri sono già iniziati. Mumble… la soluzione ottima della fatina contiene tutti i divertimenti scelti finora e non ci sono altri divertimenti compatibili. Quindi la soluzione ottima della fatina non contiene altri divertimenti e quelli scelti finora da Pinocchio sono una soluzione ottima.

Strategie golose: Scegliere lattività che inizia per prima Scegliere lattività che dura meno tempo Non funziona Scegliere lattività incompatibile con il minor numero di altre attività Non funziona

Strategia che funziona: Scegliere lattività che termina per prima. ActivitySelector(Att) AttScelte = Ø, AttComp = Att while AttComp Ø in AttComp scegli lattività a che termina per prima, aggiungi a a AttScelte e togli da AttComp tutte le attività incompatibili con a return AttScelte

Per implementarla supponiamo le attività a 1,...,a n ordinate per tempo di fine non decrescente f 1... f n Altrimenti possiamo ordinarle in tempo O(n log n) ActivitySelector(a, s, f, n) // f 1... f n A = {a 1 }, k = 1 for m = 2 to n if s[m] f[k] A = A {a m }, k = m return A

1 4 isifiisifi tempo a1a1 a2a2 a3a3 a4a4 a5a5 a6a6 a7a7 a8a8 a9a9 a 10 a 11 a1a1 a2a2 a3a3 a4a4 a5a5 a6a6 a7a7 a8a8 a9a9 a 10 a f[k]f[k] ActivitySelector(a, s, f, n) A = {a 1 }, k = 1 for m = 2 to n if s[m] f[k] A = A {a m }, k = m return A

La soluzione trovata contiene quattro attività Due domande: 1)La soluzione trovata con lalgoritmo goloso è lunica possibile che contiene quattro attività? 2)La soluzione trovata con lalgoritmo goloso è ottima o esistono anche soluzioni con più di quattro attività?

1 4 isifiisifi tempo a1a1 a2a2 a3a3 a4a4 a5a5 a6a6 a7a7 a8a8 a9a9 a 10 a