Algoritmi greedy. Gli algoritmi che risolvono problemi di ottimizzazione devono in genere operare una sequenza di scelte per arrivare alla soluzione

Transcript

1 Algoritmi greedy Gli algoritmi che risolvono problemi di ottimizzazione devono in genere operare una sequenza di scelte per arrivare alla soluzione Gli algoritmi greedy sono algoritmi basati sull idea di fare sempre scelte che sembrano ottime al momento della scelta. IMPORTANTE: Non sempre è garanta la correttezza, ma sono spesso molto semplici ed efficienti.

2 Problema della selezione di attività Problema: Siano date N attività in competizione tra loro per l utilizzo di una certa risorsa. Trovare l allocazione ottimale della risorsa, cioè il sottoinsieme di cardinalità massima delle attività che la possano condividere senza creare conflitti S={1,2,,N} un insieme di attività Ad ogni attività i S sono associati s i = tempo di inizio (attivazione) f i = tempo di fine (conclusione) tali che s i f i

3 Problema della selezione di attività Definizione: Due attività i e j si dicono compatibili se gli intervalli [s i, f i ] e [s j, f j ] sono disgiunti, cioè non si sovrappongono. In altre parole se vale f j s i oppure f i s j Problema (riformulato): Dato l insieme di attività S={1,2,,N}, trovare il massimo sottoinsieme di attività tra loro compatibili.

4 Problema della selezione di attività Problema (riformulato): Dato l insieme di attività S={1,2,,N}, trovare il massimo sottoinsieme di attività tra loro compatibili. ❶ Partiamo con un insieme A di attività inizialmente vuoto ❷ Inseriamo in A l attività j col minimo tempo di terminazione ❸ Fra le attività rimanenti compatibili con j selezionare l attività i col minore tempo di terminazione aggiungere l attività selezionata i ad A ❹ Se esistono altre attività compatibili con i, torniamo al passo ❸, altrimenti terminamo

5 Problema della selezione di attività ❶ Assumiamo le attività siano ordinate in modo crescente rispetto al tempo di fine. f 1 f 2 f N ❷ Siano I=[s 1,, s N ] e F=[f 1,, f N ] i vettori contenenti i tempi di inizio (non ordinati) e di fine (ordinati) ❸ Greedy-Activity-Selection(S,F) A = {1}; j = 1 for i = 2 to length[i] do if I[i] F[j] then A = A {i} j = i ❹ Al termine l inseme A contiene la soluzione greedy al problema. Tempo: (n), (n log n) se dobbiamo prima ordinare le attività

6 i s i f 1:1-4 i : :0-6 4: : Criterio: attività più lunga :5-9 7:6-10 8:8-11 9: : Criterio: attività che finisce prima 9 3 attività attività

7 i s i f i :1-4 6:5-9 2:3-5 7:6-10 3:0-6 8:8-11 4:5-7 9:8-12 5:3-8 10:

8 i s i f i :1-4 6:5-9 2:3-5 7:6-10 3:0-6 8:8-11 4:5-7 9:8-12 5:3-8 10:

9 i s i f i :1-4 6:5-9 2:3-5 7:6-10 3:0-6 8:8-11 4:5-7 9:8-12 5:3-8 10:

10 Selezione di attività: correttezza Teorema: L algoritmo Greedy-Activity-Selection produce soluzioni di dimensione massima per il problema della selezione delle attività. Dimostrazione: Per assunzione dell algoritmo, le N attività sono ordinate per tempo di fine, quindi la prima attività è quella che termina per prima. Dimostriamo innanzitutto che esiste una soluzione ottima che inizia con la prima attività (proprietà della scelta greedy) Sia A S sia una qualsiasi soluzione ottima. Ordiniamola per tempi di fine crescenti. Supponiamo che A[1] = S[k] e k 1 (cioè la prima attività di A non è quella con tempo di terminazione minore in S) Quindi vale f 1 < f k.

11 Selezione di attività: correttezza Teorema: L algoritmo Greedy-Activity-Selection produce soluzioni di dimensione massima per il problema della selezione delle attività. Dimostrazione: A S sia una qualsiasi soluzione ottima (ordinata per tempi di fine) con A[1] = S[k] e k 1. Quindi vale f 1 < f k. Possiamo quindi costruire un altra soluzione B = A - {k} + {1}; B è una soluzione perchè vale f 1 < f k e quindi nessun vincolo di compatibilità è violato. B è anche ottima perchè ha lo stesso numero di attività della soluzione ottima A. B è quindi una sol. ottima che inizia con la scelta greedy.

12 Selezione di attività: correttezza Teorema: L algoritmo Greedy-Activity-Selection produce soluzioni di dimensione massima per il problema della selezione delle attività. Dimostrazione: Quindi esiste una soluzione ottima che inizia con la prima attività (passo base proprietà della scelta greedy). Dopo la scelta greedy, il problema si riduce al sottoproblema di trovare la massima sequenza di attività compatibili con la prima. Il sottoproblema è quindi di cercare di una sequenza massima di attività tra S = {i S : s i f 1 } (if nel codice) Se A è una soluzione ottima, la soluzione ottima del sottoproblema S è allora A = A - {1}. Dimostriamolo!

13 Selezione di attività: correttezza Teorema: L algoritmo Greedy-Activity-Selection produce soluzioni di dimensione massima per il problema della selezione delle attività. Se A è una soluzione ottima, la soluzione ottima del sottoproblema S è A = A {1}. Se A non fosse ottima, esisterebbe un B maggiore di A per lo stesso sottoproblema S = {i S : s i f 1 }. Ma aggiungendo l attività 1 a B, otterremo una soluzione B per S migliore di A (contraddizione).

14 Selezione di attività: correttezza Teorema: L algoritmo Greedy-Activity-Selection produce soluzioni di dimensione massima per il problema della selezione delle attività. Abbiamo provato che esiste una soluzione ottima che inizia con la prima attività e Dopo la prima scelta greedy, rimaniamo col sottoproblema (analogo) di cercare di una sequenza massima di attività in un insieme S = {i S : s i f 1 }. Per induzione si può allora dimostrare facilmente che data una qualsiasi soluzione ottima, essa contiene al suo interno le soluzioni ottime dei suoi sottoproblemi (proprietà della sottostruttura ottima). Quindi la sequenza di scelte greedy determina una soluzione ottima (correttezza dell'algoritmo).

15 Algoritmi Greedy : problema del cambio di denaro Input Un numero intero positivo n Output Il più piccolo numero intero di banconote per cambiare n dollari usando pezzi da 20, 10, 5, 1 dollaro. Esempi Criterio di scelta greedy n = 58, 7 banconote: n = 18, 5 banconote: Algoritmo Dispensa una banconota alla volta Ad ogni passo, utilizza la banconota più grande che non superi la cifra rimanente.

16 Punti per garantire l ottimalità Proprietà della scelta greedy Una soluzione globalmente ottima può esser ottenuta effettuando, in sequenza, delle scelte localmente ottime (greedy). Proprietà della sottostruttura ottima Una soluzione ottima al problema contiene le soluzioni ottime dei sottoproblemi

17 Problema del cambio di denaro Teorema: Il problema del cambio di denaro precedente soddisfa sia la proprietà della sottostruttura ottima che la proprietà della scelta greedy. Dimostrazione (cenni): Se b 1,,b k è una soluzione ottima al problema di cambiare n dollari, b 2,,b k è una soluzione ottima per il problema di cambiare n b 1 v 1 dollari (la banconota b 1 vale v 1 dollari). Se non lo fosse. La seconda parte (scelta greedy) si basa sul fatto che non è possibile che in una soluzione ottima non compaia la scelta greedy.

18 Problema del cambio di denaro Dimostrazione (cenni): Assumiamo b 1,,b k sia una soluzione ottima, che la banconota h sia la più grande non superiore all importo n e che h non compaia nella soluzione. Analizzando i casi possibili, si nota che se h non supera n, esisterà sempre nella soluzione un insieme di almeno due biglietti di taglia inferiore ad n la cui somma sia proprio h (tutti i tagli sono infatti divisibili per qualsiasi dei tagli minori). Quindi sostituendo nella soluzione il biglietto di taglia maggiore si otterrebbe una soluzione migliore di b 1,,b k, il che è una contraddizione.

19 Esercizio Scrivere una programma MATLAB che legge dal file processi.txt una lista di processi individuati da due valori: tempo di inzio e tempo di fine. Es I processi hanno bisogno della CPU per poter essere eseguiti, e la CPU può essere assegnata ad un solo processo per volta. Il programma deve restituire la lista dei processi (es. vettore di indici) a cui può essere assegnata la CPU, massimizzando il numero di processi eseguiti.

20 Programmazione Dinamica (PD, con 'la' non 'il'!!) Altra tecnica per risolvere problemi di ottimizzazione, più generale degli algoritmi greedy La programmazione dinamica risolve un problema di ottimizzazione componendo le soluzioni dei sottoproblemi

21 Caratteristiche della programmazione dinamica Risolve i problemi in modo bottom-up: si parte da problemi piccoli e se ne compongono le soluzioni per trovare soluzioni di problemi di dimensioni più grandi. Si applica nei casi in cui un problema ha la proprietà della sottostruttura ottima.

22 Differenza con i metodi divide et impera I metodi divide et impera (esempio: ordinamento con mergesort) procedono top-down: la scomposizione produce problemi che vengono risolti in modo indipendente. Nei problemi a cui si applica la PD, la scomposizione produce sottoproblemi che non sono indipendenti: la soluzione di alcuni sottoproblemi richiede di risolvere i medesimi sottoproblemi.

23 PD versus divide et impera (segue) I metodi divide et impera si applicano quando la scomposizione in sottoproblemi produce problemi tutti distinti. La PD si applica quando la scomposizione in sottoproblemi produce piu volte gli stessi sottoproblemi. Per evitare di risolvere piu volte gli stessi sottoproblemi, si memorizzano le soluzioni dei sottoproblemi in una tabella.

24 PD versus metodi greedy Programmazione dinamica e metodi greedy si applicano entrambi a problemi di ottimizzazione in cui vale la proprieta della sottostruttura ottima. Nei metodi greedy, le scelte ad ogni passo dipendono da un criterio esterno (appetibilità), ogni scelta determina un sottoproblema Nella PD le scelte dipendono dalla soluzione dei sottoproblemi

25 PD versus metodi greedy (segue) I metodi greedy agiscono in modo top-down: riducono progressivamente un problema a sottoproblemi di dimensioni decrescenti. I metodi basati sulla PD procedono bottom-up risolvendo per primi i problemi più piccoli. I metodi greedy sono molto piu efficienti di quelli basati sulla programmazione dinamica che devono provare tutte le alternative per fare una scelta ottima. La PD ha un applicabilità maggiore rispetto ai metodi greedy.

26 Sviluppo di un algoritmo di programmazione dinamica 1. Caratterizzazione della struttura di una soluzione ottima 2. Definizione ricorsiva del valore di una soluzione ottima. 3. Calcolo iterativo del valore di una soluzione ottima mediante una strategia bottom-up 4. Costruzione di una soluzione ottima a partire dal valore calcolato

27 Esempio: Problema dello zaino 0/1 La programmazione dinamica permette di risolvere il problema dello zaino 0/1, che non ammette una soluzione con i metodi greedy - o 1, o 2,...,o n oggetti - w 1, w 2,..., w n pesi - v 1, v 2,...,v n valori - Capacità zaino W. Obiettivo: massimizzare il valore trasportato rispettando la capacità.

28 Caratterizzazione della struttura di una soluzione ottima Definiamo: M[i, j] = il massimo valore trasportabile con un peso j e potendo selezionare gli oggetti 1,, i

29 Caratterizzazione della struttura di una soluzione ottima Considera una soluzione ottima in cui si hanno a disposizione gli articoli 1,, i e un carico j se i non è incluso nella soluzione ottima M[i, j] = M[i-1, j] se i è incluso nella soluzione ottima M[i, j] = M[i-1, j - w i ] + v i, e deve valere j w i

30 Condizioni limite M[i, 0] = 0 per ogni i M[0, j] = 0 per ogni j Posso calcolare in modo iterativo (bottom-up) i valori di M[i, j] a partire da M[0, 0] per valori crescenti di i e j. Se ho n articoli e un peso W il valore di una selezione ottima sarà dato alla fine da M[n, W]

31 Definizione ricorsiva del valore di una soluzione M[0, j] = 0 M[i, 0] = 0 M[i, j] = M[i-1, j] se j < w i M[i, j] = max {M[i-1, j], v i + M[i-1, j - w i ]} se j w i

32 Calcolo iterativo del valore di una soluzione ottima DynamicKnapsack01(W, w, v) for j = 0 to W % inizializzazione M [0,j] 0 for i = 0 to n % inizializzazione M [i,0] 0 for i = 1 to n for j = 1 to W if (j w i ) then M[i, j] max {M[i-1, j], v i + M[i - 1, j - w i ]} else M[i, j] M [i-1, j];

33 Costruzione di una soluzione ottima a partire dal valore calcolato L'algoritmo ritorna la matrice M contenente i valori delle soluzioni ottime per vari sottoproblemi. Partendo dalla cella M[n, W], risalire nella colonna M[:, W] per capire come costruire la soluzione. Esempio: O 1 v 1 = 10, w 1 = 5 O O O W = O O O O O

34 Complessità dell algoritmo La complessità dell algoritmo di programmazione dinamica per lo zaino 0/1 è O(nW) dove n è il numero degli articoli e W è il peso dello zaino. Notare che W può essere arbitrariamente grande rispetto a n (ad esempio può essere W = 2 n )