Sei sulla pagina 1di 51

Raffaele Pesenti

MATEMATICA III
dispense sulle lezioni di
Programmazione Dinamica
del Prof. Walter Ukovich
giugno 1998
Consorzio Nettuno
-
Universit di Trieste
2
Indice
1 INTRODUZIONE................................................................................................................................................... 3
1.1 INTRODUZIONE ..................................................................................................................................................... 3
1.2 ESEMPIO: LA GESTIONE DELLE SCORTE................................................................................................................... 4
1.3 SCOPI E OBIETTIVI ................................................................................................................................................. 4
1.4 TESTI.................................................................................................................................................................... 5
1.5 DOMANDE ED ESERCIZI ......................................................................................................................................... 6
2 FONDAMENTI ...................................................................................................................................................... 7
2.1 ELEMENTI DI UN SISTEMA DINAMICO...................................................................................................................... 7
2.2 VALUTAZIONE DI UN SISTEMA DINAMICO............................................................................................................... 8
2.3 FORMALIZZAZIONE DI UN PROBLEMA DI PROGRAMMAZIONE DINAMICA.................................................................. 9
2.4 DOMANDE ED ESERCIZI ......................................................................................................................................... 9
3 BASI TEORICHE................................................................................................................................................. 12
3.1 IL PRINCIPIO DI OTTIMALIT ............................................................................................................................... 12
3.2 CALCOLO RICORSIVO DEL COSTO......................................................................................................................... 13
3.3 PROCEDURA REGRESSIVA DI SOLUZIONE .............................................................................................................. 14
3.4 STRATEGIA DI CONTROLLO OTTIMA...................................................................................................................... 15
3.5 PROCEDURA PROGRESSIVA.................................................................................................................................. 16
3.6 DOMANDE ED ESERCIZI ....................................................................................................................................... 17
4 SOLUZIONE DI UN PROBLEMA TRAMITE PROGRAMMAZIONE DINAMICA...................................... 19
4.1 IL PROCESSO DI SOLUZIONE DI UN PROBLEMA....................................................................................................... 19
4.2 UN ESEMPIO: FORMULAZIONE.............................................................................................................................. 20
4.3 UN ESEMPIO: SOLUZIONE (PROCEDURA REGRESSIVA)............................................................................................ 22
4.4 UN ESEMPIO: SOLUZIONE (PROCEDURA PROGRESSIVA).......................................................................................... 24
4.5 SOLUZIONE COME PERCORSO MINIMO .................................................................................................................. 25
4.6 DOMANDE ED ESERCIZI ....................................................................................................................................... 26
5 PERCORSI SU GRAFI ........................................................................................................................................ 27
5.1 FORMULAZIONE DEL PROBLEMA.......................................................................................................................... 27
5.2 SOLUZIONE (PROCEDURA PROGRESSIVA).............................................................................................................. 29
5.3 SOLUZIONE (PROCEDURA REGRESSIVA)................................................................................................................ 31
5.4 L'ALGORITMO DI DIJKSTRA.................................................................................................................................. 33
5.5 PERCORSO MINIMO TRA TUTTE LE COPPIE DI NODI................................................................................................. 35
5.6 DOMANDE ED ESERCIZI ....................................................................................................................................... 38
6 ATTRIBUZIONE DI RISORSE........................................................................................................................... 40
6.1 FORMULAZIONE DEL PROBLEMA.......................................................................................................................... 40
6.2 SOLUZIONE (PROCEDURA REGRESSIVA)................................................................................................................ 41
6.3 DOMANDE ED ESERCIZI ....................................................................................................................................... 42
7 SCORTE............................................................................................................................................................... 45
7.1 RAGIONI DELLE SCORTE ...................................................................................................................................... 45
7.2 COSTI DELLE SCORTE .......................................................................................................................................... 46
7.3 DIMENSIONAMENTO DELLE SCORTE E TEMPIFICAZIONE DEGLI ORDINI ................................................................... 46
7.4 PROBLEMA DELLE SCORTE: FORMULAZIONE......................................................................................................... 47
7.5 PROBLEMA DELLE SCORTE: SOLUZIONE................................................................................................................ 48
7.6 ESEMPIO............................................................................................................................................................. 49
7.7 DOMANDE ED ESERCIZI ....................................................................................................................................... 51
3
1 Introduzione
1.1 Introduzione
1.2 Esempio: la gestione delle scorte
1.3 Scopi e obiettivi
1.4 Testi
1.5 Domande ed esercizi
1.1 Introduzione
Questo testo raccoglie e commenta le lezioni sulla Programmazione Dinamica svolte dal
Prof. Walter Ukovich allinterno del corso di Matematica III.
La Programmazione Dinamica una metodologia matematica che si sviluppata negli anni
50, principalmente ad opera di Richard Bellman. Essa permette di affrontare alcune classi di
problemi in cui devono essere prese una serie di decisioni interdipendenti in sequenza.
Programmare significa infatti:
- pianificare, decidere attivit future,
- scrivere programmi per un calcolatore,
- decidere per il meglio, ottimizzare,
e, quindi, in matematica si parla di Programmazione Dinamica, Programmazione Lineare o, in
generale, di Programmazione Matematica.
Con il termine dinamico, invece, si intende che vi sono:
- decisioni in sequenza, ripetute,
- decisioni passate che influenzano quelle future.
La Programmazione Dinamica permette di risolvere quei problemi che possono essere affrontati
per stadi successivi. Essa si basa sul Principio di Ottimalit di Bellman
1
:
"Una politica ottima ha la propriet che,
qualunque siano lo stato e le decisioni
iniziali, l'insieme delle decisioni future
devono costituire una politica ottima
rispetto allo stato in cui si giunti in
base alle decisioni compiute fino al
momento attuale."

1
Quanto segue una libera traduzione da: R. Bellman: Dynamic Programming, Princeton, N.J, Princeton University
Press 1957.
4
Si consideri, ad esempio, il percorso ottimo che unisce due localit l
0
, l
n
. Il Principio di
Ottimalit afferma che ogni sottopercorso compreso in esso, tra una qualunque localit intermedia l
i
e la finale l
n
, deve essere a sua volta ottimo (in generale ogni sottopercorso, che unisce una coppia
di localit intermedie, deve essere ottimo). Alla luce di tale principio la Programmazione Dinamica
risolve un problema prendendo una decisione alla volta. Ad ogni passo essa determina la politica
ottima per il futuro, indipendentemente dalle scelte passate, nell'ipotesi che anche queste ultime
siano state compiute nel modo migliore.
La Programmazione Dinamica , quindi, efficacemente applicabile ogni qualvolta il problema
originale pu essere decomposto in un insieme di sottoproblemi di minore dimensione e quando il
costo pagato (o il profitto ottenuto) esprimibile come una somma di costi elementari, associati ad
ogni singola decisione, eventualmente funzione dello stato. Pi in generale il costo deve essere
espresso, attraverso un qualche operatore, come composizione di costi elementari, ognuno
dipendente da una singola decisione.
1.2 Esempio: la gestione delle scorte
Nell'ipotesi che all'inizio di ogni giornata si possa decidere se e quanta merce ordinare, il costo
complessivo della gestione delle scorte nell'arco di un dato periodo pu essere espresso come
somma dei costi elementari pagati ogni singolo giorno. In particolare questi ultimi costi hanno una
componente variabile, legata al valore e/o alla quantit della merce in magazzino, ed una
componente fissa, legata ad ogni emissione di un ordine di acquisto.
Ogni giorno la decisione ottima determinata dalla risposta alle seguenti domande:
- conviene ordinare oggi, o rimandare lordine a domani?
- (nel caso di risposta positiva alla prima domanda) quanto ordino oggi?
Le risposte dipendono da quanto si ha in deposito, il che funzione di quanto si ordinato il giorno
prima, e del rapporto tra il peso della componente fissa e di quella variabile dei costi. A seconda del
valore di tale rapporto pu, infatti, convenire emettere tanti ordini di piccola dimensione o,
viceversa, mantenere molta merce a magazzino. La decisione corrente condizionata dalle scelte
passate ed influenza quelle future, ma, in ogni caso, il costo pagato per essa pu essere espresso in
termini della sola quantit di merce attualmente in deposito e dell'eventuale emissione di un nuovo
ordine.
1.3 Scopi e obiettivi
Lo scopo di questo testo di introdurre alcuni dei concetti base che permettono l'applicazione della
Programmazione Dinamica nella sua versione pi elementare, applicata cio a sistemi discreti e
deterministici, su orizzonte temporale finito. A tal fine sono proposti anche alcuni esempi che hanno
applicazione nel modo reale e che, al contempo, sono facilmente trattabili dal punto di vista
matematico.
5
Questo testo organizzato come segue: nei prossimi due capitoli sono introdotte le nozioni
teoriche necessarie per una corretta comprensione ed applicazione della Programmazione Dinamica;
nei capitoli rimanenti sono discussi alcuni esempi di applicazione di suddetta metodologia.
Lo studente dovrebbe cercare di fare proprio il metodo di ragionamento utilizzato nella
Programmazione Dinamica, piuttosto che memorizzare meccanicamente concetti e risultati. Per
questo motivo opportuno che, al termine di ogni capitolo, lo studente verifichi mentalmente la
comprensione di quanto presentato e cerchi di rispondere alle domande e agli esercizi proposti.

Obiettivo del corso e di questo testo mettere lo studente in condizione di:
capire quando applicare la Programmazione Dinamica sfruttandone le caratteristiche e le
propriet;
risolvere semplici problemi reali facilmente riconducibili a quelli presentati nel testo;
usare criticamente la Programmazione Dinamica per affrontare problemi nuovi, non trattati
esplicitamente nelle lezioni.
1.4 Testi
Testo di riferimento
F.S. Hillier, G.J. Lieberman: Introduction to Operations Research, quinta edizione, McGraw-Hill
1990, capitolo 11 (Dynamic Programming).
Altri testi di consultazione
- E. Denardo: Dynamic Programmig in: J.J. Moder, S.E. Elamghraby: Handbook of Operations
Research I, van Nostrand 1978.
- D. Bertsekas: Dynamic Programming and Optimal Control, Athena Scientific 1995.
Il testo di Hillier e Lieberman introduttivo e di facile lettura. Il capitolo di Denardo un'utile
sintesi, pu servire di ripasso a chi ha gi una minima conoscenza di base. Il terzo testo
certamente il pi completo. Bertsekas , infatti, forse l'autore correntemente pi importante per
quanto riguarda la Programmazione Dinamica, i suoi libri, anche se avanzati, sono comunque di
facile lettura.
Il testo di Hillier e Lieberman pu essere utilizzato per una semplice introduzione alle
applicazioni della Programmazione Dinamica a sistemi stocastici. Il testo di Bertsekas pu servire
per l'approfondimento di tali tematiche, ma soprattutto fondamentale del nel caso si voglia
applicare la Programmazione Dinamica su orizzonti temporali di cui non sia fissata a priori la
lunghezza.
I risultati pi recenti riguardanti la Programmazione Dinamica e le sue applicazioni sono
pubblicati su riviste scientifiche. Tali riviste, generalmente disponibili nelle biblioteche delle
6
Universit italiane, afferiscono ai settori di: Ricerca Operativa, Controlli Automatici, Economia,
solo per citarne alcuni.
1.5 Domande ed esercizi
1. Spiegare in che senso il Principio di Ottimalit garantisce l'indipendenza delle decisioni future da
quelle compiute al passo corrente.
2. Presentare esempi di applicazione del Principio di Ottimalit.
3. Descrivere l'algoritmo, che implicitamente si utilizza, per raggiungere un luogo dove non si
mai stati in precedenza, ma che si trova vicino a localit gi note.
4. Descrivere l'algoritmo, che implicitamente si utilizza, per costruire un meccanismo costituito da
tanti sottocomponenti relativamente autonomi.
5. Descrivere il criterio con cui si decide che quantit comperare di ogni prodotto quando si fa la
spesa (al supermercato, sotto casa, ecc.).
7
2 Fondamenti
2.1 Elementi di un sistema dinamico
2.2 Valutazione di un sistema dinamico
2.3 Formalizzazione di un problema di Programmazione Dinamica
2.4 Domande ed esercizi
In questo capitolo sono introdotti i concetti fondamentali per trattare sistemi dinamici
deterministici, in cui quindi tutto noto senza incertezze, che evolvono in tempo discreto, ovvero
in cui le decisioni sono prese in istanti predeterminati, e.g., all'inizio della giornata o alla fine di
ogni mese.
2.1 Elementi di un sistema dinamico
Gli elementi che consentono di definire un sistema dinamico a tempo discreto e la sua evoluzione
sono:
- gli istanti temporali o stadi, ovvero i momenti in cui vengono prese le decisioni;
- il controllo, ovvero l'insieme informativo che permette di descrivere i termini delle decisioni
prese nel tempo;
- le quantit esogene, ovvero quelle quantit non controllabili che comunque influenzano
l'evoluzione del sistema;
- lo stato, ovvero l'insieme informativo minimo che, in un dato istante temporale, permette di
conoscere l'evoluzione futura del sistema stesso, una volta note le realizzazioni dei controlli e
delle azioni esogene;
- la funzione di trasformazione dello stato, ovvero la legge, anche tempovariante, che descrive
l'evoluzione del sistema. Tale legge, in funzione dello stato corrente, del controllo applicato e
delle azioni esogene, permette di determinare lo stato che verr raggiunto nell'istante temporale
successivo.
Questi elementi sono rappresentati matematicamente tramite i valori assunti dalle seguenti
variabili o funzioni:
- la variabile discreta tempo t, t [0,], dove T detto orizzonte del problema;
- le variabili di controllo u(t), u(t)U(t), dove U(t) l'insieme dei controlli ammissibili;
- le variabili esogene z(t), z(t)Z(t), dove Z(t) l'insieme delle quantit esogene che si possono
presentare;
- le variabili di stato x(t), x(t)X(t), dove X(t) l'insieme degli stati ammissibili;
- la funzione di trasformazione dello stato f, f:XUZNX, tale che:
x(t+1)=f(x(t),u(t),z(t),t). (2.1)
8
Nel problema di gestione delle scorte, introdotto nel capitolo precedente, le singole giornate sono
gli istanti temporali, l'entit dell'ordine emesso all'inizio di ogni giornata il valore del controllo, la
domanda che deve essere soddisfatta corrisponde alle quantit esogene, il livello delle scorte
all'inizio della giornata lo stato del sistema e, infine, la legge di conservazione dei flussi delle
merci definisce la funzione di trasformazione dello stato. Tale funzione deve imporre che il livello
di magazzino x(t+1) all'istante successivo dipenda dal livello attuale x(t), dalla domanda da
soddisfare z(t) e dalla dimensione dell'ordine effettuato all'inizio della giornata u(t), secondo, ad
esempio, la seguente equazione:
x(t+1)=x(t)+u(t)-z(t). (2.2)
In merito sempre allo stesso problema si deve osservare che sia il controllo sia lo stato possono
essere soggetti a vincoli fisici o contrattuali. Molto spesso, infatti, i lotti ordinati possono assumere
solo alcune dimensioni prefissate, mentre il livello delle scorte deve ovviamente essere non
negativo e non eccedere le dimensioni massime del magazzino. Nel decidere il controllo ottimo si
deve infine tenere conto che la domanda nota a priori nel caso deterministico, mentre al pi
descritta attraverso una distribuzione di probabilit nel caso stocastico.
2.2 Valutazione di un sistema dinamico
L'evoluzione di un sistema dinamico valutata in termini di costi (o di profitti). Questi ultimi, che
possono essere tempovarianti, in generale dipendono: dagli stati assunti dal sistema, dalle azioni di
controllo adottate e dalle quantit esogene. Ad esempio nel caso di gestione delle scorte sono
presenti sia costi funzione dello stato, i costi di mantenimento, che i costi funzione del controllo, i
costi di rifornimento.
La Programmazione Dinamica, come gi anticipato nell'introduzione, pu essere efficacemente
applicata ogni qualvolta il costo (o il profitto) complessivo decomponibile. In altre parole il costo
complessivo deve essere espresso come composizione di costi elementari pagati separatamente in
base a ogni singola decisione presa e agli stati raggiunti. In questo contesto, nel seguito, si ritiene
che possa essere definita una funzione di costo, g:XUZNX, che esprima il costo (elementare)
pagato all'intraprendere l'azione di controllo u(t) al tempo t, quando lo stato vale x(t) e le variabili
indipendenti valgono z(t). Per semplicit si assume che il costo sia additivo, cio che il costo
complessivo nell'intervallo di tempo [0,T] sia dato dalla somma di tutti i costi elementari
g(x(t),u(t),z(t),t), per t=0,1,,T-1, ed eventualmente un costo g(x(T),T) legato allo stato finale
raggiunto. Il costo complessivo , quindi, espresso dal seguente valore
) T ), T ( x ( g ) t ), t ( z ), t ( u ), t ( x ( g
1 T
0 t
+

=
. (2.3)
In molti casi applicativi il valore finale dello stato imposto dal problema, quindi la componente
di costo g(x(T),T) pu essere omessa poich indipendente dalle decisioni intraprese. In seguito si
9
ipotizza che si verifichino sempre tali condizioni, che quindi siano dati sia lo stato iniziale x
0
che lo
stato finale x
T
. In ogni modo non dovrebbe essere difficile per il lettore generalizzare i risultati alle
situazioni in cui una pluralit di stati finali siano ammissibili.
2.3 Formalizzazione di un problema di Programmazione Dinamica
Alla luce di quanto visto fino a questo momento si pu ritenere che un problema sia affrontabile
per mezzo della Programmazione Dinamica quando pu essere enunciato come segue:
Formulazione canonica:
Dati un orizzonte temporale T e un sistema dinamico, ovvero:
- i vincoli di stato X(t) e di controllo U(t);
- la sequenza z(t);
- le funzioni di transizione dello stato f e di costo (addittivo) g;
- i valori iniziale x
0
=x(0) e finale x
T
=x(T) dello stato;
determinare, rispetto a tutte le sequenze di controlli u(t) ammissibili, la sequenza ottima u*(t) che
minimizza il costo complessivo.
Nei prossimi capitoli sono presentati, formalizzati e risolti, alcuni dei problemi classicamente
affrontati con la Programmazione Dinamica.
2.4 Domande ed Esercizi
2.1 Un pezzo meccanico devessere sottoposto a tre successive operazioni, ciascuna operazione
pu essere effettuata in uno di quattro centri (o macchine) diversi.
Il costo di ogni operazione dipende dal centro in cui essa viene eseguita e dal centro in cui
stata effettuata loperazione precedente.
Si vuole determinare su quale centro effettuare ciascuna operazione in modo da minimizzare il
costo complessivo. Formulare il problema in modo canonico. (per soluzione vedi Cap. 4)
tabelle dei costi
centro 1 2 3 4
35 40 30 54
prima operazione
10
centro attuale 1 2 3 4
1 105 100 85 90
2 90 85 100 95
3 100 90 95 105
centro precedente
4 110 105 120 110
seconda operazione
centro attuale 1 2 3 4
1 70 75 85 80
2 85 90 80 95
3 90 70 85 80
centro precedente
4 80 85 90 75
terza operazione
2.2 Una ditta che lavora su commessa deve pianificare la propria produzione per la prossima
settimana. Tale ditta ha a disposizione 4 ordini e considera lavorativi tutti sette i giorni. La
produzione di ogni ordine pu essere interrotta con profitto al termine di ogni giornata e fatta
completare da altre ditte in subappalto con conseguente variazione dei profitti. Ogni ordine non
richiede pi di quattro giorni di lavorazione e i profitti ottenibili da ogni commessa sono
presentati nella tabella seguente. Massimizzare il profitto complessivo. Formulare il problema
in modo canonico.
tabella dei profitti
commessa A B C D
0 0 0 0 0
1 6 10 5 11
2 10 10 8 15
3 12 12 15 18
giorni lavorazione
4 15 20 17 20
2.3 Un candidato ad una alta carica pubblica deve decidere che aree visitare negli ultimi 5 giorni
della sua campagna elettorale. Pi a lungo il candidato presente in una zona, maggiore
l'incremento del numero di voti che si attende di ricevere dagli abitanti del posto. Massimizzare
l'incremento complessivo del numero di voti che ricever il candidato. Formulare il problema in
modo canonico.
11
tabella dell'incremento dei voti attesi
(in migliaia)
zona A B C D
0 0 0 0 0
1 7 6 5 4
2 8 11 8 9
3 9 15 14 10
4 10 15 14 11
giorni di soggiorno
5 10 15 14 12
12
3 Basi teoriche
3.1 Il Principio di Ottimalit
3.2 Calcolo ricorsivo del costo
3.3 Procedura regressiva di soluzione
3.4 Strategia di controllo ottima
3.5 Procedura progressiva di soluzione
3.6 Domande ed esercizi
In questo capitolo sono introdotte le basi teoriche della Programmazione Dinamica. In particolare
oltre al Principio di Ottimalit, enunciato a parole nell'introduzione, sono presentate le procedure
ricorsive progressive e regressive utilizzate nella soluzione dei problemi.
3.1 Il Principio di Ottimalit
Dato un sistema dinamico e un orizzonte temporale T, si definisce traiettoria l'insieme degli stati
x(t) assunti dal sistema, a partire dallo stato iniziale x(0) = x
0
, in funzione delle azioni di controllo
intraprese e dell'equazione di transizione dello stato. Inoltre si definisce ammissibile una sequenza
di controlli u(t), con u(t)U(t), per ogni t=0,1,...,T-1, che produca una traiettoria x(t) per cui
x(t)X(t), per ogni t=0,1,...,T-1, e x(T)=x
T
.
I concetti di traiettoria e controlli ammissibili sono alla base del Principio di Ottimalit.
Principio di Ottimalit:
Si consideri un sistema dinamico lungo un orizzonte temporale [0,T]. Sia u*(t) la sequenza
ottima dei controlli e x*(t) la relativa traiettoria ottima. Si consideri quindi un relativo
sottoproblema con:
- orizzonte: da t a t, con 0t<tT
- stato iniziale: x=x*(t)
- stato finale: x=x*(t).
Le sequenze u*(t) e x*(t) del problema originale sono ottime anche per il sottoproblema, se
considerate per t=t,t+1,t+2,...,t-1.
La dimostrazione del Principio di Ottimalit pu essere data per assurdo. Si assuma che per il
sottoproblema esista un controllo ammissibile u'(t) che produca una traiettoria x'(t) (vedi fig.3.1) da
x a x migliore di x*(t), per t=t,t+1,t+2,...,t-1, allora, in riferimento al problema originale,
esisterebbe un controllo ammissibile che conduce ad una nuova traiettoria ottenuta dalla
giustapposizione delle sottosequenze x*(t), per t=0,1,...,t'-1, x'(t), t=t,t+1,...,t-1, x*(t), per
t=t,t+1,...,T-1. La nuova traiettoria, poich i costi sono addittivi, sarebbe migliore di x*(t), per
t=0,1,2,...,T-1, ma questo in contraddizione con l'ottimalit di x*(t). Ne consegue che l'ipotesi che
esista x'(t) falsa.
13
Fig. 3.1: traiettorie nello spazio degli stati
Il Principio di Ottimalit viene sfruttato dalla Programmazione Dinamica per calcolare la politica
di controllo ottimo in modo ricorsivo.
3.2 Calcolo ricorsivo del costo
Dato un problema di programmazione dinamica, con stato iniziale x
0
, si definisca F(x
0
,0) il costo
minimo cumulato da pagare sull'orizzonte temporale da 0 a T:
),z(k),k) g(x(k),u(k min ) 0 , F(x
1 T
0 k
U u(k)
0

= . (3.1)
Si noti che la conoscenza del valore di F(x
0
,0) corrisponde ovviamente alla soluzione del
problema.
In generale si definisca F(x,t) costo minimo del sottoproblema su orizzonte [t,T] quando lo stato
iniziale vale x:
),z(k),k) g(x(k),u(k min F(x,t)
1 T
t k
U u(k)

= . (3.2)
Il costo addittivo, la funzione di trasformazione dello stato ed il Principio di Ottimalit
permettono di riscrivere la (3.2) come:
)} 1 t , ,t) ) t ( z , u , x ( F(f ) ,t g(x,u,z(t) { min F(x,t)
U u
+ + =

. (3.3)
x x* *( (t t) )
x x* *( (0 0) )
x x
x x
x x* *( (T T) )
x x ( (t t) )
x x* *( (t t ) )
x x* *( (t t ) )
14
In particolare l'equazione (3.3) deve essere interpretata nel modo seguente: poich il costo su
orizzonte [t,T] a partire dallo stato x risulta essere la somma del costo g(x,u,z(t),t) pagato all'istante
attuale t, e del costo complessivo residuo F(x(t+1),t) che si deve pagare a partire dallo stato che si
raggiunge in t+1, ne consegue che, per trovare il costo minimo F(x,t) da t a T, si deve compiere il
passo da t a t+1 scegliendo il punto darrivo x(t+1)=f(x,u,z(t),t) in modo da minimizzare la somma
di queste due componenti.
In linguaggio matematico le equazioni come (3.3) sono dette ricorsive. In tali equazioni la stessa
funzione, e.g., F(.,.), compare, con argomenti diversi, sia a destra che a sinistra del segno di eguale
e deve essere calcolabile in tutto lo spazio in cui definita, XT nel caso di F(.,.), a partire dalla
conoscenza dei valori assunti in alcuni punti di riferimento. Il concetto di ricorsione formalizza il
comportamento tipico del matematico che cerca di risolvere un problema riconducendosi ad uno
risolto in precedenza. Un elementare esempio di ricorsione il seguente modo di definire i numeri
fattoriali: 0!=1; n!=n(n-1)!. Noto il fattoriale di zero, possibile conoscere il fattoriale di qualunque
numero naturale a partire dal fattoriale del numero precedente.
3.3 Procedura regressiva di soluzione
L'equazione ricorsiva (3.3) alla base della Programmazione Dinamica poich permette di calcolare
il valore di F(x,t), se sono noti i valori di F(x,t+1) in corrispondenza di ogni valore di x. A partire
da questa osservazione in seguito presentata una procedura regressiva, o allindietro (backward),
che ricava la funzione di costo cumulato F(x
0
,0). In particolare il valore di F(x
0
,0) determinato
procedendo iterativamente allindietro nel tempo a partire dall'istante finale.
Al tempo T, per le ipotesi formulate nel capitolo precedente,
F(x,T)=0 per x=x
T
F(x,T)= per xx
T
.
Noto il valore di F(.,.) in T possibile ricavare F(.,.) in T-1dallequazione ricorsiva (3.3):
)} T , ,t) ) t ( z , u , x ( F(f ) 1 ),T 1 g(x,u,z(T { min ) 1 F(x,T
U u
+ =

. (3.4)
In particolare se, per ogni stato ammissibile x in T-1, u*(x(T-1)) un controllo a costo minimo che
quando applicato conduce il sistema nello stato x
T
, i.e., x
T
= f(x,u*(x(T-1)),z(T-1),T-1), allora
F(x,T-1) pu essere scritto come:
F(x,T-1)=g(x,u*(x(T-1)),z(T-1),T-1)+F(f(x,u*(x(T-1)),z(T-1),T-1),T)=
=g(x,u*(x(T-1)),z(T-1),T-1)+ F(x
T
,T)=g(x,u*(x(T-1)),z(T-1),T-1)+0. (3.5)
15
Si osservi che in (3.5) il costo F(x,T-1) solo funzione dello stato assunto in T-1.
Noto F(.,.) al passo T-1, si pu ricavare il controllo, e quindi il costo F(.,.), al passo T-2:
)} 1 T , ,t) ) t ( z , u , x ( F(f ) 2 ),T 2 g(x,u,z(T { min ) 2 F(x,T
U u
+ =

(3.6)
In questo caso se, per ogni stato ammissibile x in T-2, u*(x(T-2)) un controllo per cui minima la
somma tra il costo g(x,u*(x(T-2)),z(T-2),T-2), pagato all'istante corrente, e il costo residuo
F(f(x,u*(x(T-2)),z(T-2),T-2),T-1), che rimane da pagare che quando il sistema raggiunge lo stato
successivo, allora F(x,T-2) pu essere scritto come:
F(x,T-2)=g(x,u*(x(T-2)),z(T-2),T-2)+F(f(x,u*(x(T-2)),z(T-2),T-2),T-1). (3.7)
Anche il costo F(x,T-2) pu essere calcolato in base al solo stato assunto dal sistema in tale
istante. Infatti il costo attuale, g(x,u,z(T-2),T-2), dipende da x, u e z(T-2), ma non dagli stati o
controlli precedenti o futuri, mentre il costo residuo, F(x(T-1),T-1), dipende dallo stato assunto in
T-1 che per esprimibile in funzione di x, u e z(T-2). Ripetendo il ragionamento, ad ogni
iterazione, si possono ricavare F(x,T-3),...,F(x,0) tramite il calcolo del controllo ottimo, ovvero il
valore di u che corrisponde al minimo in (3.3).
La procedura regressiva stata presentata in modo da procedere per valori decrescenti del tempo
trascorso t, ma un semplice cambio di variabile permette di ragionare per valori crescenti del tempo
rimanente (anche detto time-to-go), t=T-t. In entrambi i casi la procedura permette di ricavare la
funzione F(x,t) per tutti i valori di x e t, ovvero qualunque sia lo stato e l'istante iniziale del
problema in considerazione (questa propriet detta principio dellinvariant embedding). Il valore
F(x
0
,0) cercato quindi solo un caso particolare di quanto ottenuto. L'informazione a cui si perviene
in realt molto pi ricca e permette di definire una "strategia di controllo" ottima.
3.4 Strategia di controllo ottima
Una qualunque funzione , :XTU, che restituisce il valore di un possibile controllo a partire
dallo stato e dall'istante attuale:
u=(x(t),t) (3.8)
detta strategia o politica di controllo. In pratica una politica di controllo ci che indica che
decisione prendere qualunque sia il valore dello stato. Per quanto riguarda la Programmazione
Dinamica l'equazione ricorsiva determina non solo la sequenza ottima dei controlli per il problema
oggetto di considerazione, ma anche, pi in generale, una anche strategia ottima *:
u*(t)=*(x(t),t). (3.9)
16
Infatti la soluzione dellequazione ricorsiva (3.3) fornisce, per ogni valore di x e t, il controllo
ottimo u* da applicare.
La politica di controllo *, determinata attraverso la (3.3), utile quando, a causa di disturbi od
imprecisioni del modello, lo stato del sistema evolve in modo diverso da quello previsto. In questi
casi * fornisce lo stesso indicazioni sulle scelte da compiere e queste indicazioni, nella speranza
che gli errori modellistici siano sufficientemente piccoli, non dovrebbero discostarsi molto da quelle
realmente ottime.
3.5 Procedura progressiva
Nel Paragrafo precedente stata presentata una procedura regressiva di soluzione dei problemi di
Programmazione Dinamica, viceversa in questo paragrafo viene presentata una procedura
progressiva basata su un'equazione ricorsiva in avanti (forward).
Dato un problema di Programmazione Dinamica, si definisce funzione di costo minimo cumulato
in avanti la funzione G(x,t). Essa rappresenta il costo pagato fino ad un determinato istante
temporale t. In particolare G(x,t) la soluzione del sottoproblema che ha orizzonte [0,t] e stato
finale x:
),z(k),k) g(x(k),u(k min G(x,t)
t
0 k
U u(k)

= . (3.10)
Determinare il valore G(x
T
,0) corrisponde quindi a risolvere il problema originale.
Il costo addittivo, la funzione di trasformazione dello stato ed il principio del massimo
permettono di riscrivere la (3.10) come:
} x ) t , ,t) ) t ( z , u , y ( f : u | ) ,t g(x,u,z(t) ) t , y ( G { min ,t) 1 G(x
X y
= + = +

. (3.11)
In particolare l'equazione (3.11) deve essere interpretata nel modo seguente: poich il sistema, a
partire da x
0
al tempo 0, giunge in x al tempo t+1 passando per lo stato intermedio y al tempo t, tale
stato y deve essere scelto in modo da minimizzare la somma del costo pagato fino al suo
raggiungimento e del costo attuale.
L'equazione (3.11) permette di calcolare il valore di G(xt+1), se sono noti i valori di G(y,t) in
corrispondenza di ogni y. Essa pu quindi essere risolta con una ricorsione progressiva, procedendo
in avanti nel tempo, a partire dalla seguente inizializzazione:
G(x,1)=g(x
0
,u,z(0),0) con u:f(x
0
,u,z(0),0)=x. (3.12)
17
In altre parole, per raggiungere lo stato generico x al tempo 1, si deve pagare solo il costo legato al
fatto che ci si trova nello stato x
0
al tempo 0 e che viene applicato il controllo a costo minimo che
permette una transizione di stato da x
0
a x. Determinata l'espressione di G(y,1), la si inserisce
nellequazione ricorsiva (3.11) e ricava G(x,2). Si prosegue quindi fino ad arrivare a G(x
T
,T).
Con la ricorsione in avanti si ricava la funzione G(x,t) per tutti i valori di x e t, si determina,
quindi, la soluzione del problema oggetto di considerazione per qualunque orizzonte temporale non
superiore a T e qualunque stato finale raggiungibile.
3.6 Domande ed Esercizi
3.1 Scrivere le equazioni ricorsive regressiva e progressiva del costo per il problema presentato
nell'Esercizio 2.1.
3.2 Scrivere le equazioni ricorsive regressiva e progressiva del costo per il problema presentato
nell'Esercizio 2.2.
3.3 Scrivere le equazioni ricorsive regressiva e progressiva del costo per il problema presentato
nell'Esercizio 2.3.
3.4 Si devono eseguire quattro successive lavorazioni, ciascuna lavorazione pu essere effettuata in
uno di quattro centri diversi.
Il costo di ogni lavorazione dipende dal centro in cui essa viene eseguita e dal centro in cui
stata effettuata la lavorazione precedente.
Si vuole determinare su quale centro effettuare ciascuna lavorazione in modo da minimizzare il
costo complessivo. Formulare il problema in modo canonico e scrivere le equazioni ricorsive
regressiva e progressiva.
tabelle dei costi
centro 1 2 3 4
17 20 16 25
prima lavorazione
centro attuale 1 2 3 4
1 51 54 43 48
2 45 44 52 48
3 52 45 42 53
centro precedente
4 60 58 63 59
seconda lavorazione
18
centro attuale 1 2 3 4
1 140 150 170 160
2 170 185 164 188
3 180 139 170 162
centro precedente
4 190 168 182 155
terza lavorazione
centro attuale 1 2 3 4
1 80 85 95 90
2 95 100 90 105
3 100 80 95 90
centro precedente
4 90 95 90 95
quarta lavorazione
19
4 Soluzione di un problema tramite Programmazione
Dinamica
4.1 Il processo di soluzione di un problema
4.2 Un esempio: formulazione
4.3 Un esempio: soluzione (procedura regressiva)
4.4 Un esempio: soluzione (procedura progressiva)
4.5 Soluzione come percorso minimo
4.6 Domande ed esercizi
In questo capitolo, attraverso la discussione di un esempio, viene presentata la maniera in cui
usualmente risolto un problema di Programmazione Dinamica.
4.1 Il processo di soluzione di un problema
In generale il processo di risoluzione di un problema avviene per fasi e pu essere schematizzato
come segue:
Fig. 4.1: Fasi di soluzione di un problema
All'interno delle realt produttive o di servizio il management ha la percezione dell'esistenza di
problemi, ma spesso non riesce a focalizzarli. Per superare tali difficolt necessaria quindi una
prima fase di analisi, che conduce a precisare il problema di interesse per la realt in cui si opera.
Nella fase di analisi si determinano gli elementi del problema attraverso l'individuazione degli attori
decisionali e dei loro poteri (variabili decisionali), degli obiettivi, dei vincoli e dei disturbi esterni.
A questa prima fase segue quella di formulazione del problema, durante la quale viene sviluppato
un modello logico/matematico del problema reale. Segue poi la fase di risoluzione algoritmica,
dove vengono determinate le soluzioni del problema applicando algoritmi logico/matematici al
modello sviluppato nella fase precedente. Ovvie ragioni economiche impongono infine che, una
volta determinata la soluzione, i risultati vengano applicati. In realt pochi problemi, per, possono
ritenersi risolti in via definitiva attraverso una singola esecuzione delle attivit associate alle fasi di
Analisi Formulazione
Risoluzione
algoritmica
Ridefinizione
Realt Problema Modello Soluzione
20
soluzione appena descritte. Occorre, infatti, spesso ridefinire alcuni elementi del problema. Tale
fase di ridefinizione , in generale, motivata da nuove conoscenze sul sistema dovute ai nuovi dati
raccolti a seguito di difficolt insorte nella formulazione modello matematico oppure durante il
primo tentativo di applicazione delle soluzioni ottenute. Durante la ridefinizione del problema
vengono spesso modificate le ipotesi riguardanti sia le possibilit decisionali degli attori coinvolti
che i vincoli del sistema.
Il processo di risoluzione di un problema pu ciclare pi volte attraverso le differenti fasi; la
presenza di una fase di ridefinizione permette di individuare soluzioni sempre migliori.
All'interno del processo sopradescritto, se la formulazione del modello matematico del problema
strutturata in modo canonico, la Programmazione Dinamica pu essere uno strumento utilizzato
per la risoluzione algoritmica.
4.2 Un esempio: formulazione
Dall'analisi della lavorazione cui soggetto un componente meccanico emerso il seguente
problema:
Problema di sequenziazione (descrizione a parole)
Un pezzo meccanico devessere sottoposto a tre successive operazioni, ciascuna operazione pu
essere effettuata in uno di quattro centri (o macchine) diversi.
Il costo di ogni operazione dipende dal centro in cui essa viene eseguita e dal centro in cui stata
effettuata loperazione precedente.
Minimizzare il costo complessivo determinando su quale centro effettuare ciascuna operazione.
tabelle dei costi
centro 1 2 3 4
35 40 30 54
prima operazione
centro attuale 1 2 3 4
1 105 100 85 90
2 90 85 100 95
3 100 90 95 105
centro precedente
4 110 105 120 110
seconda operazione
21
centro attuale 1 2 3 4
1 70 75 85 80
2 85 90 80 95
3 90 70 85 80
centro precedente
4 80 85 90 75
terza operazione
Nel problema in oggetto si devono prendere tre decisioni successive circa quale centro adoperare
per ciascuna operazione. L'orizzonte temporale , quindi, costituito dai tre istanti [0,1,2] in cui si
compiono le scelte e dall'istante finale, t=3, in cui si giunge dopo l'ultima decisione. Ovviamente
nessun controllo attuato in t=3, mentre, in ogni altro ogni istante temporale, il valore delle
variabili di controllo non pu che corrisponde al centro scelto per la prossima lavorazione. Indicati
con i numeri dall'1 al 4 i centri di lavoro, u(t) deve, quindi, appartenere all'insieme {1,2,3,4}, per
t=0,1,2. Le variabili di stato devono contenere tutte le informazioni che permettono di descrivere
l'evoluzione del sistema ed, in particolare, una volta deciso il controllo, devono permettere di
valutare i costi. Di conseguenza una possibile scelta che, ad ogni istante diverso da quello iniziale,
il valore delle variabili di stato corrisponda al centro in cui viene effettuata la lavorazione corrente,
x(t){1,2,3,4}, per t=1,2,3. Il valore dello stato iniziale , invece, quello nullo, x(0)=0, dove 0
indica l'assenza di lavorazioni sul pezzo. In questo contesto l'equazione di transizione dello stato
non pu che imporre che lo stato successivo (il centro su cui si effettua la prossima operazione) sia
semplicemente eguale al controllo, x(t+1)=u(t), per t=0,1,2.
Alla luce delle precedenti considerazioni il problema, prima enunciato a parole, pu essere
formalizzato matematicamente nel modo seguente:
Problema di sequenziazione (formulazione canonica):
Dati:
- orizzonte: t=0,1,2,3, T=3
- stato x(t): x(t)X(t) con X(0)={0} e X(t)={1,2,3,4}, per t=1,2,3;
- controllo u(t): u(t)U(t) con U(t)={1,2,3,4}, per t=0,1,2;
- variabili esogene z(t): non necessarie;
- funzione di transizione dello stato f(x,u,z,t): x(t+1)=u(t), per t=0,1,2;
- costo: g(x(t),u(t),t)=c(i,j,t), per t=0,1,2;
con:
i : stato attuale
j : controllo attuale
c : matrice dei costi.
- costo complessivo: c(0,u(0),0)+c(u(0),u(1),1)+c(u(1),u(2),2).
Determinare la sequenza ottima di controlli u*(t).
Date le tabelle dei costi indicate in precedenza, i valori dei parametri c(i,j,t) risultano essere:
22
matrici dei costi
t=0 controllo: u(0)=j 1 2 3 4
stato: x(0)=i 0 35 40 30 45
c(i,j,0)
t=1 controllo: u(1)=j 1 2 3 4
1 105 100 85 90
2 90 85 100 95
3 100 90 95 105
stato: x(1)=i
4 110 105 120 110
c(i,j,1)
t=2 controllo: u(2)=j 1 2 3 4
1 70 75 85 80
2 85 90 80 95
3 90 70 85 80
stato: x(2)=i
4 80 85 90 75
c(i,j,2)
4.3 Un esempio: soluzione (procedura regressiva)
Il costo del problema in esame pu essere espresso in forma ricorsiva. In particolare l'equazione
ricorsiva (regressiva) generale:
F(x,t)=min
u
{g(x,u,z(t),t)+F(f(x,u,z(t),t),t+1)}
diventa nel caso di interesse:
F(i,t)=min
j
{c(i,j,t)+F(j,t+1)}. (4.1)
Lo stato finale del sistema x(3) pu essere un qualunque valore di X(3)={1,2,3,4}, in ogni caso il
costo pagato in t=3 nullo:
F(i,3)=0 per i=1,2,3,4. (4.2)
Noto F(.,.) per t=3 si ricava F(.,.) per t=2 dallequazione ricorsiva (4.1)
F(i,2)=min
j
{c(i,j,2)+F(j,3)} (4.3)
23
lindice j relativo al minimo fornisce la politica ottima (i,t)=j. In particolare
F(1,2)=min
j
{c(1,j,2)+F(j,3)}=min{70+0,75+0,85+0,80+0}=70 : (1,2)=1; (4.4a)
F(2,2)=min
j
{c(2,j,2)+F(j,3)}=min{85+0,90+0,80+0,95+0}=80 : (2,2)=3; (4.4b)
F(3,2)=min
j
{c(3,j,2)+F(j,3)}=min{90+0,70+0,85+0,80+0}=70 : (3,2)=2; (4.4c)
F(4,2)=min
j
{c(4,j,2)+F(j,3)}=min{80+0,85+0,90+0,75+0}=75 : (4,2)=4; (4.4d)
Si consideri ad esempio l'equazione (4.4a). In essa F(1,2) indica che, se si giunge nello stato 1
all'istante 2, il costo minimo residuo da pagare di 70 e tale costo pu essere ottenuto applicando il
controllo (1,2)=1.
Noto F(.,.) per t=2 si ricava F(.,.) per t=1, infine il costo ottimo F(0,0).
Il seguente schema riassume tutte le operazioni da compiere:
Procedura regressiva:
t=3 i F(i,3)
1 0
2 0
3 0
4 0
t=2 c(i,j,2) +F(j,3)
j 1 2 3 4
1 70 75 85 80
2 85 90 80 95
3 90 70 85 80
i
4 80 85 90 75
i F(i,2) (i,2)
1 70 1
2 80 3
3 70 2
4 75 4
t=1 c(i,j,1)+F(j,2)
j 1 2 3 4
1 175 180 155 165
2 160 165 170 170
3 170 170 165 180
i
4 180 185 190 185
24
i F(i,1) (i,1)
1 155 3
2 160 1
3 165 3
4 180 1
t=0 c(0,j,0)+F(j,1)
j 1 2 3 4
i 0 190 200 195 225
i F(0,0) (0,0)
0 190 1
Una volta calcolati i valori di F(i,j), si pu, a partire da t=0, determinare la sequenza dei
controlli ottimi per il problema. In t=0 la soluzione prevede u*(0)=(0,0)=1, cio di usare il centro
1 per la prima operazione e di giungere, di conseguenza, nello stato x(1)=1. La seconda operazione
deve essere u*(1)=(1,1)=3, quindi deve essere utilizzato il centro 3 giungendo nello stato x(2)=3.
In t=2 il controllo risulta essere u*(2)=(3,2)=2, quindi l'ultima operazione deve essere svolta nel
centro 2. Il costo ottimo corrispondente di 190.
I calcoli necessari per determinare la soluzione ottima forniscono anche la strategia ottima
(i,t). Tale strategia indica l'azione di controllo migliore a partire da qualunque condizione (i,t). Se
si fosse deciso che la prima lavorazione doveva essere comunque fatta nel centro 4, poich, ad
esempio, le altre macchine erano temporaneamente in manutenzione, il valore di (4,1)
indicherebbe che la seconda lavorazione dovrebbe essere svolta nel centro 1, infine, (1,2)
imporrebbe l'ultima lavorazione di nuovo nel centro 1.
4.4 Un esempio: soluzione (procedura progressiva)
Si pu esprimere il costo del problema in esame anche tramite l'equazione ricorsiva progressiva:
G(x,t+1)=min
y
{G(y,t)+g(y,u,z(t),t)| u:f(y,u,z(t),t)=x}
che diventa nel caso di interesse:
G(j,t+1)=min
i
{G(i,t)+c(i,j,t)} (4.5)
perch f(y,u,z(t),t)=u.
All'istante t=1, G(j,1)=c(0,j,1), per j=1,2,3,4. I valori di G(.,.) per gli istanti successivi si
ricavano dallequazione ricorsiva secondo il seguente schema:
25
Procedura progressiva:
t=1 j 1 2 3 4
G(j,1) 35 40 30 45
G(i,1)+c(i,j,1)
j 1 2 3 4
1 140 135 120 125
2 130 125 140 135
3 130 120 125 135
i
4 155 150 165 155
j 1 2 3 4
G(j,2) 130 120 120 125
t=2 G(i,2)+c(i,j2)
j 1 2 3 4
1 200 205 215 210
2 205 210 200 215
3 210 190 205 200
i
4 205 210 215 200
j 1 2 3 4
G(j,3) 200 190 200 200
Una volta effettuati i calcoli si ottiene:
G(1,3)=200; G(2,3)=190; G(3,3)=200; G(4,3)=200 (4.6)
e, poich qualunque stato finale ammissibile (x(T)X
T
={1,2,3,4}), si sceglie quello pi
conveniente, cio x(3)=2. Procedendo a ritroso si pu poi determinare la sequenza delle azioni di
controllo ottime.
4.5 Soluzione come percorso minimo
Il problema del paragrafo precedente pu essere interpretato anche come problema di percorso
minimo su un grafo orientato
2
G=(N,A), dove N l'insieme dei nodi e A quello degli archi (vedi
Fig. 4.2). Il grafo G ha un nodo in N per ogni coppia (x(t),t), t=0,1,2,3, pi un nodo finale (0,T+1),
inoltre ha un arco orientato in A per ogni transizione ammissibile da un nodo (x(t),t) a un nodo
(x(t+1),t+1). Ciascun arco ha una lunghezza pari al costo della transizione corrispondente. Il
problema in oggetto si riduce, quindi, a quello di trovare il cammino pi breve da (0,0) a (0,T+1).

2
Si faccia attenzione, qui e nel seguito, a non confondere il grafo G=(N,A) con il costo dell'equazione ricorsiva G(i,t).
26
Fig. 4.2: Grafo (N,A)
In generale ogni problema di Programmazione Dinamica pu essere visto come un problema di
ricerca del percorso pi breve su un grafo caratterizzato da una struttura a livelli, o strati, in cui sono
connessi solo nodi di livelli contigui. La determinazione di un percorso minimo su un grafo un
problema semplice, ovvero il numero di operazioni necessarie a risolvere tale problema cresce al
massimo secondo una legge quadratica nel numero dei nodi, per il numero dei nodi del grafo
considerato dipende dagli stati ammissibili e questi ultimi, per certe classi di problemi, possono
essere numerosissimi, crescere cio in modo esponenziale con la dimensione del problema.
4.6 Domande ed Esercizi
4.1 Risolvere il problema presentato nell'Esercizio 2.2.
4.2 Risolvere il problema presentato nell'Esercizio 2.3.
4.3 Risolvere il problema presentato nell'Esercizio 3.4.
stato
tempo
1
0
1
0
2
3
4
2 3 4
27
5 Percorsi su grafi
5.1 Formulazione del problema
5.2 Soluzione (procedura progressiva)
5.3 Soluzione (procedura regressiva)
5.4 L'algoritmo di Dijkstra
5.5 Percorso minimo tra tutte le coppie di nodi
5.6 Domande ed esercizi
Nel capitolo precedente stato mostrato che un problema di Programmazione Dinamica pu essere
ricondotto ad un problema di percorso minimo. In questo capitolo, viceversa, un problema di
percorso minimo su un grafo generico affrontato attraverso la Programmazione Dinamica, a tal
fine il concetto di "tempo" t viene opportunamente ridefinito in senso pi ampio di quello intuitivo.
Un ottimo libro che tratta di problemi di percorsi su grafi Ahuja, Magnanti, Orlin: Network
Flows, Prentice Hall 1993.
5.1 Formulazione del problema
Si consideri ad esempio il grafo in Fig. 5.1, con p=1 e f=5.
Problema di percorso minimo (descrizione a parole)
Dato un grafo con distanze associate agli archi, trovare il percorso pi breve da un nodo di partenza
p ad uno finale f.
Fig. 5.1: Grafo di esempio
5
1
4
3 2
6
5
1
8
1
1
6
1
8
6
28
Per applicare con successo la Programmazione Dinamica, si deve scomporre il problema di
percorso minimo in una sequenza di sottoproblemi parziali in modo da poterlo affrontare attraverso
una serie di decisioni sequenziali ripetute.
Dato un grafo generico G=(N,A), sia |N| cardinalit dell'insieme N, ovvero il numero di nodi del
grafo. Si consideri quindi la sequenza dei seguenti sottoproblemi, per t=0,1,2,...,|N|-1:
Sottoproblema(t) di percorso minimo:
Trovare, quando possibile, i percorsi di lunghezza minima da p a tutti gli altri nodi in N aventi al
pi t archi.
La soluzione del sottoproblema per t=|N|-1 coincide con quella del problema originale, infatti, in
assenza di circuiti negativi, come da qui in seguito sempre assunto, un percorso ottimo visita al pi
una sola volta ogni nodo del grafo e, quindi, non pu includere pi da |N|-1 archi.
Sia G(i,t) la lunghezza del percorso pi breve con al pi t archi dal nodo di partenza p al nodo i.
Se sono note tutte le distanze G(i,t), possibile calcolare, tramite la seguente equazione ricorsiva, la
lunghezza G(j,t+1) del percorso pi breve con al pi di t+1 archi dal nodo p a un qualunque nodo j:
G(j,t+1)=min
i
{G(i,t)+c(i,j)} (5.1)
dove

=
altrimenti
se
se arco lunghezza
,
j i , 0
A ) j , i ( ), j , i (
) j , i ( c (5.2)
Confrontando l'equazione (5.1) con l'equazione ricorsiva (3.11), si pu osservare che la (5.1)
utilizza il numero massimo di rami dei percorsi in modo analogo a come viene usato il tempo t nella
(3.11).
Alla luce delle considerazioni precedenti, una possibile formulazione canonica del problema di
percorso minimo pu essere:
Problema di percorso minimo (formulazione canonica):
Dati: grafo G=(N,A) e
- orizzonte: t=0,1,2,3,...,|N|-1, T=|N|-1;
- stato x(t): nodo del percorso considerato,
X(0)={p} e X(t)=N={1,2,3,...,|N|}, per t=0,1,2,3,...,|N|-1;
- controllo u(t): prossimo nodo visitato, U(t)=N, per t=0,1,2,3,...,|N|-2;
- variabili esogene z(t): non necessarie;
- funzione di transizione dello stato f(x,u,z,t): x(t+1)=u(t), per t=0,1,2,...,|N|-2;
- costo: g(x(t),u(t),t)=c(i,j), per t=0,1,2,...,|N|-2;
con:
i : stato attuale
29
j : controllo attuale
- costo complessivo: c(p,u(0))+c(u(0),u(1))+c(u(1),u(2))+...+c(u(|N|-1),f).
Determinare la sequenza ottima di controlli u*(t) che definiscono il percorso minimo da p a f.
L'applicazione di una procedura regressiva sarebbe stata altrettanto naturale, se si fossero
considerati i seguenti sottoproblemi, per t=0,1,2,...,|N|-1:
Sottoproblema(t) regressivo di percorso minimo:
Trovare, quando possibile, i percorsi di lunghezza minima terminanti in f a partire da tutti gli
altri nodi in N avente al pi t archi.
5.2 Soluzione (procedura progressiva)
Per determinare G(.,.) nel caso di Fig. 5.1 si deve osservare che le lunghezze degli archi sono
c(i,j)
j 1 2 3 4 5
1 0 8 1 5 6
2 8 0 6 1 1
3 1 6 0 1 6
4 5 1 1 0 8
i
5 6 1 6 8 0
e che al passo 0 la funzione G(.,.) assume i seguenti valori:
G(p,0)=0; G(i,0)= per ip, (5.3)
quindi
G(j,1)=c(p,j) (5.4)
da cui
j 1 2 3 4 5
G(j,1) 0 8 1 5 6
prec(j,1) 1 1 1 1 1
dove la terza riga della tabella contiene l'ultimo nodo visitato prima di giungere in j. Si osservi che
lungo il percorso ottimo, al passo generico t, prec(j,t)=x*(t-1)=u*(t-2).
Una volta determinati i valori di G(.,.) al passo 1, possibile calcolare G(.,.) al passo 2:
G(j,2)=min
i
{G(i,1)+c(i,j)}, (5.5a)
30
prec(j)=argmin
i
{G(i,1)+c(i,j)}. (5.5b)
In particolare la seguente tabella riporta i valori G(i,1)+c(i,j) per ogni coppia i,j:
G(i,1)+c(i,j)
j 1 2 3 4 5
1 0 8 1 5 6
2 16 8 14 9 9
3 2 7 1 2 7
4 10 6 6 5 13
i
5 12 7 12 14 6
eseguendo quindi il minimo su ogni colonna, si ottengono i valori di G(j,2):
j 1 2 3 4 5
G(j,2) 0 6 1 2 6
prec(j,2) 1 4 1 3 1
Iterando la procedura, si ottengono i risultati del seguente schema:
G(i,2)+c(i,j)
t=2 j 1 2 3 4 5
1 0 8 1 5 6
2 14 6 12 7 7
3 2 7 1 2 7
4 7 3 3 2 10
i
5 12 7 12 14 6
j 1 2 3 4 5
G(j,3) 0 3 1 2 6
prec(j,3) 1 4 1 3 1
G(i,3)+c(i,j)
t=3 j 1 2 3 4 5
1 0 8 1 5 6
2 11 3 9 4 4
3 2 7 1 2 7
4 7 3 3 2 10
i
5 12 7 12 14 6
j 1 2 3 4 5
G(j,4) 0 3 1 2 4
prec(j,4) 1 2 1 3 2
31
Dai calcoli riportati nelle tabelle si deduce che lunghezza del percorso ottimo da p=1 a f=5
G(5,4)=4. Inoltre utilizzando i valori prec(j), procedendo all'indietro, si possono determinare i nodi
visitati dal percorso ottimo. In particolare, poich u*(3)=5, u*(2)=prec(5)=2, u*(1)=prec(2)=4,
u*(0)=prec(4)=3, il percorso ottimo visita nell'ordine i nodi 1, 3, 4, 2 e 5. Gli altri valori G(i,4)
indicano le lunghezze dei percorsi minimi da 1 a tutti i rimanenti nodi i.
5.3 Soluzione (procedura regressiva)
Il problema del percorso minimo pu essere risolto anche con una procedura regressiva che,
costruendo i cammini all'indietro, determina tutti i percorsi minimi che giungono in f a partire da
qualunque altro nodo del grafo, quindi anche da p. In questa procedura regressiva il tempo t
rappresenta di nuovo il numero massimo di rami dei percorsi che si stanno costruendo. In
particolare
t=T-t, (5.6)
dove t il tempo della procedura progressiva, dunque t il tempo rimanente rispetto a t'.
L'equazione regressiva generale (3.3) diventa per il problema di percorso minimo:
F(i,t+1)=min
j
{c(i,j)+F(j,t)}. (5.7)
Si osservi che in questo caso, poich si considera il tempo rimanente, l'equazione procede per
valori crescenti di t.
I valori F(i,t+1) al passo 0 sono:
F(f,0)=0; F(i,0)=, per if (5.8)
quindi
F(i,1)=c(i,f) (5.9)
da cui
i 1 2 3 4 5
F(i,1) 6 1 6 8 0
Una volta determinati i valori di F(.,.) al passo 1, possibile calcolare F(.,.) al passo 2:
F(i,2)=min
j
{c(i,j)+F(j,1)}. (5.10)
In particolare la seguente tabella riporta i valori c(i,j)+F(j,1) per ogni coppia i,j:
32
c(i,j)+F(j,1)
j 1 2 3 4 5
1 6 9 7 13 6
2 14 1 12 9 1
3 7 7 6 9 6
4 11 2 7 8 8
i
5 12 2 12 16 0
eseguendo quindi il minimo su ogni riga, si ottengono i valori di F(j,2):
i 1 2 3 4 5
F(j,2) 6 1 6 2 0
Iterando la procedura, si ottengono i risultati del seguente schema:
c(i,j)+F(j,2)
t=2 j 1 2 3 4 5
1 6 9 7 7 6
2 14 1 12 3 1
3 7 7 6 3 6
4 11 2 7 2 8
i
5 12 2 12 10 0
i 1 2 3 4 5
F(i,3) 6 1 3 2 0
c(i,j)+F(j,3)
t=3 j 1 2 3 4 5
1 6 9 4 7 6
2 14 1 9 3 1
3 7 7 3 3 6
4 11 2 4 2 8
i
5 12 2 9 10 0
i 1 2 3 4 5
F(i,4) 4 1 3 2 0
La lunghezza del percorso ottimo da p=1 a f=5 risulta essere F(1,4)=4. Gli altri valori F(i,4)
indicano le lunghezze dei percorsi minimi da tutti i rimanenti nodi i a 5.
33
5.4 L'algoritmo di Dijkstra
L'algoritmo di Dijkstra lalgoritmo classico per trovare il percorso pi breve tra due nodi p ed f in
un grafo. Esso applicabile solo nel caso in cui non esistano archi negativi e consiste nel
determinare iterativamente, per ciascun nodo, delle stime (per eccesso) della distanza minima dal
nodo di partenza. Ciascuna stima relativa al numero massimo di rami t presenti nel percorso
minimo. Le stime vengono progressivamente migliorate fino a diventare esatte. Inizialmente solo la
distanza del nodo di partenza da se stesso nota con certezza, ma, ad ogni iterazione, un nuovo
nodo incluso tra quelli la cui distanza minima da f certa:
Algoritmo Dijkstra
// inizializzazione
d(1,0)=0, distanza definitiva;
d(j,0)=, j1, distanze provvisorie;
loop
// iterazione
q=argmin{d(j,t), provvisorio};
d(q,t) distanza definitiva;
per tutti i j, con distanze provvisorie e jq,
d(j,t+1)=min{d(j,t),d(q,t)+c(q,j)}, distanze provvisorie.
end loop
Se si applica l'algoritmo di Dijkstra all'esempio di Fig. 5.1, si ottiene:
Algoritmo Dijkstra:
j 1 2 3 4 5
k=0 q=1 d(j,0) provvisori q

d(j,0) definitivi 0
d(q,0)+c(q,j) 8 1 5 6
k=1 q=3 d(j,1) provvisori 8 q 5 6
d(j,1) definitivi 0 1
d(q,1)+c(q,j) 7 2 7
34
k=2 q=4 d(j,2) provvisori 7 q 6
d(j,2) definitivi 0 1 2
d(q,2)+c(q,j) 3 10
k=3 q=2 d(j,3) provvisori q 6
d(j,3) definitivi 0 3 1 2
d(q,3)+c(q,j) 4
k=4 q=5 d(j,4) provvisori q
d(j,4) definitivi 0 3 1 2 4
I risultati sono ovviamente identici a quelli ottenuti con la procedura progressiva della
Programmazione Dinamica.
L'algoritmo di Programmazione Dinamica visto e quello di Dijkstra sono egualmente efficaci,
producono entrambi la soluzione ottima, viceversa presentano efficienza diversa in termini di
risorse adoperate: tempo e memoria. Si valuti, infatti, il numero di operazioni in funzione del
numero di nodi |N| del grafo. Il metodo di Programmazione Dinamica visto richiede |N|
2
somme ad
ogni iterazione, quindi in totale |N|
3
somme, diversamente lalgoritmo di Dijkstra richiede al pi |N|
somme ad ogni iterazione, quindi in totale |N|
2
somme, dunque lalgoritmo di Dijkstra pi
efficiente.
L'algoritmo di Programmazione Dinamica per pi generale. Si consideri, infatti, un grafo
asimmetrico, in cui la distanza tra una coppia di nodi i e j non necessariamente la stessa che tra j e
i, che possa avere archi con distanze negative, lalgoritmo di Dijkstra non funziona, invece la
Programmazione Dinamica scopre anche gli eventuali circuiti negativi.
In generale, nonostante la migliore efficienza dell'algoritmo di Dijkstra su grafi generici, pu non
convenire ricondurre un problema di Programmazione Dinamica ad un problema di percorso
minimo su grafi. Il numero di operazioni svolte dalla Programmazione Dinamica , infatti, limitato
superiormente da |X|
2
T dove |X| la dimensione dello stato del sistema. Tale limite coincide con il
numero di operazioni da svolgere per calcolare il percorso minimo sul tipo di grafo (Fig. 4.2)
associato al problema.
Si osservi, infine, che un problema di percorso minimo pu anche essere formulato e risolto
come problema di programmazione lineare. Definite, per tutti gli archi (i,j) inclusi in A, le variabili
x(i,j), che assumono valore 1 se l'arco corrispondente appartiene al percorso minimo, 0 in caso
contrario, il problema di percorso minimo risulta essere:
min
i

,j
c(i,j)x(i,j)

j
x(p,j)=1

i
x(i,f)=1 (5.10)

i
x(i,j)=
k
x(j,k) j
0x(i,j)1
35
Si possono risolvere problemi di programmazione lineare (non molto grandi) anche utilizzando i
pi comuni fogli elettronici. La programmazione lineare ha per alcuni svantaggi: pu avere
problemi di precisione, trova solo il percorso tra una coppia di nodi ed infine, essendo una
metodologia sviluppata per risolvere problemi molto pi generali, pu risultare pi difficile da
utilizzare.
5.5 Percorso minimo tra tutte le coppie di nodi
La Programmazione Dinamica, attraverso un'opportuna definizione del "tempo" t e dello stato x,
permette di determinare anche i percorsi minimi tra tutte le coppie di nodi di un grafo. In generale,
nella Programmazione Dinamica, la scelta di t e x critica per la soluzione dei problemi, la
formulazione dei quali non , quindi, sempre intuitiva ed immediata: richiede spesso una discreta
dose di creativit.
Il problema di percorso minimo tra tutte le coppie risolto dall'algoritmo di Programmazione
Dinamica di Floyd-Warshall. In tale procedura la funzione di costo cumulativa la lunghezza
d(i,j,t) del minimo fra tutti i cammini tra i nodi i e j che visitano al pi solo i nodi intermedi 1,2,...,t .
In queste ipotesi l'equazione ricorsiva diventa
d(i,j,t+1)=min{d(i,j,t),d(i,t+1,t)+d(t+1,j,t)}. (5.11)
L'equazione (5.11) esprime semplicemente il fatto che il percorso minimo che coinvolge al pi i
nodi intermedi da 1 a t+1 pu passare o meno per l'ultimo nodo t+1. Nel primo caso
d(i,j,t+1)=d(i,t+1,t)+d(t+1,j,t), altrimenti d(i,j,t+1)=d(i,j,t). Si osservi come la prima di queste
condizioni non altro che il Principio di Ottimalit.
L'algoritmo di Floyd-Warshall viene inizializzato imponendo che, per t=0, non ci siano nodi
intermedi; rimane quindi solo leventuale collegamento diretto:
d(i,j,0)=c(i,j). (5.12)
Lo schema seguente riporta l'applicazione dell'algoritmo di Floyd-Warshall al grafo in Fig. 5.1.
In particolare per ogni istante generico t sono riportate le tabelle con tutti i valori di d(i,j,t) e di
d(i,t+1,t)+d(t+1,j,t). Si osservi che con i valori riportati nella prima tabella si determinano gli
elementi della seconda e quindi, eseguendo il minimo tra elementi corrispondenti di queste due
tabelle, si calcolano, in accordo con l'equazione (5.11), gli elementi della tabella d(i,j,t+1)
dell'istante successivo.
36
Algoritmo Floyd - Warshall:
t=0 d(i,j,0) prec(i,j,0)
j 1 2 3 4 5 j 1 2 3 4 5
1 0 7 8 5 8 1 1 1 1 1 1
2 1 0 1 2 5 2 2 2 2 2 2
3 4 2 0 2 0 3 3 3 3 3 3
4 1 1 3 0 8 4 4 4 4 4 4
i
5 4 4 6 6 0
i
5 5 5 5 5 5
d(i,1,0)+d(1,j,0)
j 1 2 3 4 5
1 0 7 8 5 8
2 1 8 9 6 9
3 4 11 12 9 12
4 1 8 9 6 9
i
5 4 11 12 9 12
t=1 d(i,j,1) prec(i,j,1)
j 1 2 3 4 5 j 1 2 3 4 5
1 0 7 8 5 8 1 1 1 1 1 1
2 1 0 1 2 5 2 2 2 2 2 2
3 4 2 0 2 0 3 3 3 3 3 3
4 1 1 3 0 8 4 4 4 4 4 4
i
5 4 4 6 6 0
i
5 5 5 5 5 5
d(i,2,1)+d(2,j,1)
j 1 2 3 4 5
1 8 7 8 9 12
2 1 0 1 2 5
3 3 2 3 4 7
4 2 1 2 3 6
i
5 5 4 5 6 9
t=2 d(i,j,2) prec(i,j,2)
j 1 2 3 4 5 j 1 2 3 4 5
1 0 7 8 5 8 1 1 1 1 1 1
2 1 0 1 2 5 2 2 2 2 2 2
3 3 2 0 2 0 3 2 3 3 3 3
4 1 1 2 0 6 4 4 4 4 4 2
i
5 4 4 5 6 0
i
5 5 5 2 5 5
37
d(i,3,2)+d(3,j,2)
j 1 2 3 4 5
1 11 10 8 10 8
2 4 3 1 3 1
3 3 2 0 2 0
4 5 4 2 4 2
i
5 8 7 5 7 5
t=3 d(i,j,3) prec(i,j,3)
j 1 2 3 4 5 j 1 2 3 4 5
1 0 7 8 5 8 1 1 1 1 1 1
2 1 0 1 2 1 2 2 2 2 2 3
3 3 2 0 2 0 3 2 3 3 3 3
4 1 1 2 0 2 4 4 4 4 4 3
i
5 4 4 5 6 0
i
5 5 5 2 5 5
d(i,4,3)+d(4,j,3)
j 1 2 31 4 5
1 6 6 7 5 7
2 3 3 4 2 4
3 3 3 4 2 4
4 1 1 2 0 2
i
5 7 7 8 6 8
t=4 d(i,j,4) prec(i,j,4)
j 1 2 3 4 5 j 1 2 3 4 5
1 0 6 7 5 7 1 1 4 4 1 4
2 1 0 1 2 1 2 2 2 2 2 3
3 3 2 0 2 0 3 2 3 3 3 3
4 1 1 2 0 2 4 4 4 4 4 3
i
5 4 4 5 6 0
i
5 5 5 2 5 5
d(i,5,4)+d(5,j,4)
j 1 2 3 4 5
1 11 11 12 13 7
2 5 5 6 7 1
3 4 4 5 6 0
4 6 6 7 8 2
i
5 4 4 5 6 0
38
t=5 d(i,j,5) prec(i,j,5)
j 1 2 3 4 5 j 1 2 3 4 5
1 0 6 7 5 7 1 1 4 4 1 4
2 1 0 1 2 1 2 2 2 2 2 3
3 3 2 0 2 0 3 2 3 3 3 3
4 1 1 2 0 2 4 4 4 4 4 3
i
5 4 4 5 6 0
i
5 5 5 2 5 5
I valori di d(i,j,5) forniscono le distanze minime tra tutte le coppie di nodi. Inoltre i dati delle
tabelle prec(i,j,t) permettono di determinare i percorsi ottimi in modo del tutto analogo a quanto
fatto nel paragrafo 5.2 per una sola coppia di nodi.
Si osservi, infine, che il numero di operazioni dell'algoritmo di Floyd-Warshall limitato
superiormente da |N|
3
, dunque questo algoritmo risulta pi veloce che applicare |N| volte l'algoritmo
di Dijkstra solo nel caso di grafi densi (con molti archi), mentre non risulta conveniente nel caso di
grafi sparsi.
5.6 Domande ed Esercizi
5.1 Determinare il percorso minimo dal nodo S al nodo T sul seguente grafo:
5.2 Determinare il percorso minimo dal nodo S al nodo T sul seguente grafo:
S T
5
8
4
2
6
4
9
5
2
6
6
8 1
2
4
3
5
39
5.3 Formulare il problema presentato nell'Esercizio 2.2 come un problema di ricerca di percorso
minimo e risolverlo.
5.4 Formulare il problema presentato nell'Esercizio 2.3 come un problema di ricerca di percorso
minimo e risolverlo.
5.5 Formulare il problema presentato nell'Esercizio 3.4 come un problema di ricerca di percorso
minimo e risolverlo
S T
25
32
43
20
12
46
43
56
73
23
74
11
9
35
23
44
50
15
34
40
6 Attribuzione di risorse
6.1 Formulazione del problema
6.2 Soluzione (procedura progressiva)
6.3 Domande ed esercizi
In questo capitolo viene presentato un altro esempio di applicazione della Programmazione
Dinamica in cui il concetto di "tempo" t viene ridefinito in senso pi ampio di quello intuitivo.
6.1 Formulazione del problema
Problema di attribuzione di risorse (descrizione a parole)
Si dispone di 5 risorse, ciascuna delle quali pu essere attribuita ad una di 3 diverse attivit: A, B, C.
Il rendimento (valore) dellattribuzione dipende in maniera complessa dal numero di risorse
assegnate a ciascuna attivit, come indicato nella tabella:
rendimento dell'attribuzione
risorse assegnate 0 1 2 3 4 5
A 0 45 70 90 105 120
B 0 20 45 75 110 150 attivit
C 0 50 70 80 100 130
Attribuire le risorse alle attivit in modo da massimizzare il profitto complessivo.
Apparentemente si deve compiere ununica scelta e quindi il paradigma della Programmazione
Dinamica non si applica in modo naturale. Si pu per "serializzare" (decomporre) il problema
decidendo per unattivit alla volta, in un ordine prefissato qualunque. In quest'ottica l'attivit i, su
cui si sta correntemente prendendo una decisione, deve essere interpretata come il valore della
variabile "tempo" nella formulazione canonica, di conseguenza lorizzonte coincide con il numero
complessivo N di attivit. Le variabili di controllo u(i) corrispondono alle risorse da attribuire ad
ogni attivit i. Lo stato x(i), che deve riassumere leffetto delle scelte passate e definire i limiti entro
cui si possono prendere le decisioni future, pu corrispondere alle risorse rimanenti da attribuire alle
attivit i,i+1,...,N. Lequazione di stato, che quindi deve descrivere la dinamica delle risorse rimaste
disponibili, risulta essere:
x(i+1)=x(i)-u(i) (6.1)
Il profitto g(u(i),i), i cui valori sono elencati nella tabella dei rendimenti, dipende solo da controllo
u(i) e tempo i, non dallo stato x(i). In particolare si osservi la sua dipendenza esplicita dal tempo.
Assegnare le stesse risorse ad attivit diverse comporta, infatti, profitti differenti.
41
Problema di attribuzione di risorse (formulazione canonica):
Dati:
- orizzonte: t=A,B,C,
- stato x(t): x(t)X(t) con X(A)={5} e X(t)={0,1,2,3,4,5} per t=B,C;
- controllo u(t): 0u(t)x(t), per t=A,B,C;
- variabili esogene z(t): non necessarie;
- funzione di transizione dello stato f(x,u,z,t): x(t+1)=x(t)-u(t), per t=A,B;
- profitto: g(x(t),u(t),t)=g(u,i), per t=A,B,C;
con:
u : controllo attuale
i : tempo attuale
c : matrice dei rendimenti.
- profitto complessivo: c(u(A),A)+c(u(B),B)+c(u(C),C).
Determinare la sequenza ottima di controlli u*(t).
Dalla tabella dei rendimenti si deducono in modo ovvio i valori di g(u,i) che risultano essere:
g(u,i)
i A B C
0 0 0 0
1 45 20 50
2 70 45 70
3 90 75 80
4 105 110 100
u
5 120 150 130
6.2 Soluzione (procedura regressiva)
Il costo del problema in esame F(x,i), che rappresenta il massimo rendimento che si pu ottenere
distribuendo x risorse alle attivit i,i+1,...,N, pu essere espresso in forma ricorsiva regressiva:
F(x,i)=max
u
{g(u,i)+F(x-u,i+1)}. (6.2)
Per determinare il valore di F(.,.) al passo N si osservi che conviene sempre assegnare tutte le
risorse non attribuite in precedenza all'ultima attivit, da cui
u(N)=x(N), (6.3)
ne consegue che
F(x,N)=g(x,N), (6.4)
42
dove il primo argomento della funzione di costo g(.,.) il valore del controllo, che, per la (6.3),
coincide con il valore dello stato.
Applicando la formula ricorsiva, si ottengono i risultati riportati nel seguente schema:
Procedura regressiva:
i=C x 0 1 2 3 4 5
F(x,C) 0 50 70 80 100 130
i=B g(u,B)+F(x-u,C)
x 0 1 2 3 4 5
0 0 50 70 80 100 130
1 20 70 90 100 120
2 45 95 115 125
3 75 125 145
4 110 160
u
5 150
x 0 1 2 3 4 5
F(x,B) 0 50 70 95 125 160
i=A g(u,A)+F(x-u,B)
x 0 1 2 3 4 5
0 0 50 70 95 125 160
1 45 95 115 140 170
2 70 120 140 165
3 90 140 160
4 105 155
u
5 120
x 0 1 2 3 4 5
F(x,A) 0 50 95 120 140 170
La soluzione ottima indica che si ottiene un rendimento massimo pari a 170 assegnando una
risorsa ad A, tre a B e una a C.
6.3 Domande ed esercizi
6.1 Problema dello Zaino. Siano dati uno zaino di capacit massima C = 25 e un insieme
N={1,2,3,4} di tipologie di oggetti, ognuno dei quali ha il valore e il peso indicati nella tabella
seguente. Determinare quali e quanti oggetti inserire nello zaino al fine di massimizzare il
valore complessivo del suo contenuto.
43
oggetto
i
peso
a
i
valore
v
i
1 6 15
2 4 10
3 3 7
4 1 2
{Suggerimento: definire come stato/tempo la capacit residua. L'equazione ricorsiva risulta
essere:
)} a x ( F v { max ) x ( F
i i
x a : i
i
+ =
<
(6.5)
con F(0)=0; da cui
F(1)=v
4
=1;
F(2)=v
4
+F(1)=4
F(3)=max{v
3
+F(0),v
4
+F(2)}=7
......
Oltre una certa capacit residua il valore di F(.) esprimibile in modo molto semplice, perch?}
6.2 Un'azienda deve scegliere quali tra N commesse lanciare nel prossimo mese (30 giorni). Ogni
commessa per dare profitto deve essere completata senza interruzione. Pianificare le attivit al
fine di massimizzare i profitti. {Suggerimento: simile al problema precedente anche se vi un
unica istanza per commessa, conviene ordinare le commesse secondo il rapporto profitto su
durata}
commessa durata profitto
1 9 18
2 2 7
3 7 25
4 4 8
5 10 21
6 6 12
7 12 27
8 6 10
9 13 35
10 2 4
11 4 12
12 5 14
6.3 Programmazione Lineare. Risolvere, tramite la Programmazione Dinamica, il seguente
problema:
44
0 x , x
300 x x 3
350 x 2 x
x 7 x 3 z max
2 1
2 1
2 1
2 1

+
+
+ =
(6.6)
{Suggerimento: considerare come istante di "tempo" la decisione circa una variabile e come
stato (bidimensionale) la quantit residua delle risorse descritte dai termini noti. Si ottengono di
conseguenza le seguenti equazioni ricorsive:
} x 7 { max ) 2 ), w , v (( F
2
w x 0
v x 2 0
2 2
2 2
2 2


= (6.7)
)} 2 ), x 3 w , x v (( F x 3 { max ) 1 ), w , v (( F
1 1 1 1 1
w x 3 0
v x 0
1 1
1 1
1 1
+ =


. (6.8)
Poich il valore di F((v
2
,w
2
),1) uguale a 7min{v
2
/2,w
2
}, la (6.8) pu essere scritta in modo
esplicito e il problema risolto calcolando F((350,300),1).
Si osservi che, in generale, la Programmazione Dinamica non il metodo migliore per risolvere
problemi di programmazione lineare.}
6.4 Risolvere il seguente problema di programmazione lineare:
0 x , x
280 x x 5
240 x 4 x 3
x 7 x 2 z max
2 1
2 1
2 1
2 1

+
+
+ =
(6.9)
6.5 Risolvere il seguente problema di programmazione intera:
Z x , x
250 x x 3
340 x 4 x
x 7 x 2 z max
2 1
2 1
2
1
2
2
1
2

+
+
+ =
(6.9)
45
7 Scorte
7.1 Ragioni delle scorte
7.2 Costi delle scorte
7.3 Dimensionamento delle scorte e tempificazione degli ordini
7.4 Problema delle scorte: formulazione
7.5 Problema delle scorte: soluzione
7.6 Esempio
7.7 Domande ed esercizi
In questo capitolo viene introdotto il problema delle scorte ed presentata la soluzione di un caso
paradigmatico. Il lettore interessato pu consultare uno dei seguenti due libri, entrambi di facile
lettura anche se abbastanza avanzati, per un successivo approfondimento:
- G. Urgeletti Tinarelli: La gestione delle scorte nelle imprese commerciali e di produzione,
EtasLibri 1992;
- E.A. Silver, R. Peterson: Decision systems for inventory management and production planning,
Wiley 1985.
7.1 Ragioni delle scorte
Le scorte sono materiali che aspettano di essere utilizzati (lavorati, assemblati, distribuiti, venduti,
adoperati, consumati, ecc.). Esse possono posizionarsi in qualunque fase del processo produttivo a
seconda che riguardino materie prime, semilavorati o prodotti finiti.
Le scorte sono giustificate fondamentalmente per le tre seguenti ragioni:
1) motivo "transazionale": per ridurre i costi fissi (es. di trasporto). In ambiente produttivo, infatti,
si possono spesso ottenere economie di scala: i costi meno che proporzionali alla quantit.
Ordinare dei lotti grandi pu, quindi, essere pi conveniente che ordinare le stesse quantit in
lotti di dimensioni minori;
2) motivo "precauzionale": per garantirsi contro le incertezze dei fornitori, dei trasporti, della
produzione o del mercato per quanto riguarda i tempi di consegna, le quantit disponibili o la
qualit dei materiali. Le scorte, infatti "disaccoppiano" processi contigui riducendone la mutua
influenza;
3) motivo "speculativo": per garantirsi o per guadagnare in attesa o in previsione di aumenti di
valore o di costo.
Tenere delle scorte non per indolore, comporta dei costi che vanno oltre quello di acquisto
della merce.
46
7.2 Costi delle scorte
In generale i costi associati ad un qualunque sistema sono suddivisi tra variabili, ovvero funzione di
almeno una delle grandezze che caratterizzano la dinamica del sistema, e fissi, ovvero indipendenti
dalla dinamica osservata e generalmente funzione della sola struttura fisica del sistema.
Per quanto riguarda le scorte si possono ritenere sempre presenti sia costi variabili, almeno quelli
legati alla quantit di materiale immagazzinato (livello delle scorte), sia i costi fissi, almeno quelli
legati ad ogni nuovo ordine di rifornimento.
In prima approssimazione il costo di mantenimento, che modella, ad esempio, i costi legati agli
interessi da pagare alle banche per il capitale immobilizzato, i costi di gestione del magazzino per
gli spazi, movimentazione e sicurezza, i costi di deterioramento e obsolescenza, considerato
proporzionale alla quantit e al tempo di permanenza dei materiali in magazzino. Il costo di
rifornimento, che modella i costi legati al trasporto, ordine, ecc., invece ritenuto un costo fisso e,
quindi, ha un valore costante indipendente dalla quantit ordinata. Il costo di penuria, che modella
il rischio di rottura di scorta, vale a dire della incapacit di rispondere ad una richiesta di materiali
e, quindi, della possibilit di blocco della produzione, mancata vendita o disaffezione dei clienti, ,
infine, spesso difficile da monetizzare in modo preciso, ma in generale ritenuto proporzionale alla
domanda non soddisfatta e alla durata della penuria.
La presenza di costi di mantenimento non trascurabili ha determinato lo sviluppo del cosiddetto
approccio Just-In-Time (JIT) alla gestione della produzione. Secondo tale linea di pensiero si
devono tenere le scorte al minimo, o non tenerne addirittura (scorte zero). Si devono effettuare i
rifornimenti solo quando il materiale deve essere adoperato in modo da annullare i tempi di attesa.
La riduzione delle scorte per, se diminuisce il costo di mantenimento, pu indurre un aumento
degli altri costi: di rifornimento e di penuria.
7.3 Dimensionamento delle scorte e tempificazione degli ordini
Nel paragrafo precedente si osservato come livelli di scorta meno elevati diminuiscono i costi di
mantenimento, ma aumentano quelli di rifornimento e di penuria, e viceversa. Per una corretta
politica di gestione delle scorte si deve, quindi, trovare il punto di equilibrio pi conveniente.
Tenere delle scorte , infatti, spesso inevitabile, conviene quindi farlo nel modo meno oneroso.
In generale difficile determinare una politica di gestione ottima, se non altro a causa delle
inevitabili stocasticit che affliggono, ad esempio, la domanda, la produzione, i trasporti o i prezzi.
In pratica esistono diverse politiche approssimate, tra le quali deve essere scelta quella pi adatta
alla situazione contingente. Tali politiche, per la cui descrizione si rimanda ai riferimenti all'inizio
del capitolo, differiscono per:
- modalit di gestione del magazzino, che pu essere ad inventario periodico, in cui la
valutazione dellentit delle scorte disponibili viene fatta periodicamente, oppure a controllo
continuo, in cui un sistema informativo aggiorna in tempo reale la situazione del magazzino, ad
ogni ingresso ed ogni uscita di materiale;
47
- modalit di gestione delle scorte, che pu essere a intervalli fissi, cio con riordino periodico,
oppure a punto dordine, in cui si riordina quando la scorta raggiunge un dato valore;
- dimensione dell'ordine, che pu essere a lotti fissi, in cui si riordina una quantit costante,
oppure a ripristino, in cui si riordina la quantit necessaria a ricostituire la scorta massima.
7.4 Problema delle scorte: formulazione
Problema delle scorte (descrizione a parole)
Si consideri un sistema di gestione delle scorte a intervalli fissi di riordino in cui: la domanda su un
dato orizzonte temporale nota a priori senza incertezze, anche se non costante nel tempo; non
sono ammesse rotture di scorta, ovvero tutta la domanda deve essere soddisfatta quando viene
espressa, senza alcun ritardo; il livello iniziale delle scorte zero; gli ordini di rifornimento
vengono eseguiti istantaneamente; il costo fisso k di rifornimento non dipende dalla quantit
ordinata e viene imputato in ciascun periodo in cui si emette un ordine; il costo di mantenimento
proporzionale, tramite la costante h, sia alla quantit di merce presente in magazzino, sia al tempo
di permanenza.
Minimizzare il costo complessivo di gestione delle scorte.
La caratteristica principale del problema oggetto di considerazione la domanda nota con
certezza, ma variabile nel tempo. Tale tipo di domanda si presenta in diversi casi reali:
- assemblaggio di prodotti complessi, in cui si sa in anticipo quali componenti saranno necessari e
quando;
- contratti di fornitura, in cui si possono prevedere tempi di consegna differiti per quantit definite,
oppure contratti riguardanti prodotti con domanda stagionale, in cui la stagionalit pu essere
indotta, ad esempio, anche da promozioni o sconti;
- gestione di pezzi di ricambio per prodotti che escono di produzione, in cui per propria natura la
domanda si riduce nel tempo, oppure gestione di prodotti con interventi di manutenzione
programmata, in cui, quindi, anche le necessit sono programmate.
In pratica, anche nei casi enunciati sopra, la domanda tanto meno certa quanto pi lontana nel
futuro. Pu quindi essere conveniente applicare un approccio ad orizzonte mobile (rolling horizon).
Con tale metodo si pianifica per un lungo periodo, si attua solo la parte iniziale del piano, quindi si
ripianifica a partire dal punto cui si arrivati. Un simile approccio ha il vantaggio di evitare una
pianificazione "miope", che tenga conto solo dei dati assestati, avendo per la possibilit di
modificare le decisioni, se varia il contesto in cui sono state prese.
Il problema delle scorte considerato richiede di decidere la quantit da ordinare in ciascun
periodo, dunque un tipico problema di Programmazione Dinamica.
Problema di scorte (formulazione canonica):
- orizzonte: t = 1, 2, 3, ..., n+1, T=n+1;
- stato x(t): livello delle scorte allinizio del periodo t (ovvero alla fine del periodo t-1);
48
X(1)={0}, X(n+1)={0} e X(t)=R
+
, per t =1,2,3,...,n; infatti non sono ammesse rotture di scorta e
allinizio il magazzino vuoto (altrimenti bisogna detrarre la scorta iniziale dai primi ordini);
- controllo u(t): quantit ordinata all'istante t, supponendo che lordine sia emesso (ed eseguito)
prima della domanda, U(t)=R
+
, per t=1,2,3,...,n;
- variabili esogene z(t): domanda d(t), per t=1,2,3,...,n;
- funzione di transizione dello stato f(x,u,z,t): x(t+1)=x(t)-u(t)+d(t), per t=1,2,...,n;
- costo: g(x(t),u(t),t)=hx(t)+k(u(t)), per t=1,2,...,n;
con:

=
>
=
0 ) t ( u 0
0 ) t ( u 1
)) t ( u (
se
se
(7.1)
Determinare la sequenza ottima di controlli u*(t) che definiscono il costo minimo da 1 a n+1.
7.5 Problema delle scorte: soluzione
Il problema descritto nel paragrafo precedente stato studiato da Wagner e Whitin nel 1958 e viene
descritto in dettaglio in
- E.A. Silver, R. Peterson: Decision systems for inventory management and production planning,
Wiley 1985, Capitolo 6;
- H.L. Lee, S. Nahmias: Single-Product, Single-Location Models, in: S.C. Graves, A.H.G.
Rinnooy Kan, P.H. Zipkin (eds.): Handbook In Operations Research and Management Science -
Vol. 4: Logistics of Production and Inventory, Wiley 1993, Capitolo 1, pp. 18-25.
Prima di tentare di risolvere secondo una qualunque metodologia il problema in questione, si
deve osservare che vale la seguente propriet:
Propriet fondamentale
Non conveniente emettere un ordine se il magazzino non vuoto, formalmente:
x(t)u(t)=0 per t=1,2,...,n. (7.2)
Per assurdo si supponga che si sia emesso un ordine u(t)>0 quando anche x(t)=x'>0. Allora tale
strategia pu essere migliorata riducendo di x lordine precedente a u(t) e, viceversa, aumentando
u(t) di x. In tale modo la domanda lo stesso soddisfatta, ma si risparmia il costo di mantenimento
relativo alla quantit x.
Immediata conseguenza della propriet fondamentale che la quantit da ordinare u(t) pu
assumere solo determinati valori:
u(t)=d(t) (7.3)
oppure =d(t)+d(t+1)
49
oppure =d(t)+d(t+1)+d(t+2)
oppure =d(t)+d(t+1)+d(t+2)+d(t+3)
.......
In altre parole ha senso ordinare solo la quantit necessaria a soddisfare esattamente la domanda di
prossimi m giorni. Ad ogni istante t si deve soltanto decidere il valore di m, poich la quantit da
ordinare ne una conseguenza.
Il problema delle scorte in considerazione pu essere affrontato attraverso la Programmazione
Dinamica, ma pu anche essere formulato e risolto come un problema di ricerca del percorso
minimo su un grafo orientato G=(N,A). In particolare il grafo G ha un nodo in N per ogni periodo t,
t=1,2,...,n, pi un nodo finale n+1, inoltre ha un arco orientato in A per ciascuna coppia di nodi (i,j)
tali che l'istante j sia successivo a i, per i=1,2,...,n, e j=i+1,i+2,...,n+1. Ogni arco (i,j)A ha una
lunghezza pari al costo c(i,j) pagato globalmente per un ordine emesso il periodo i e smaltito entro
periodo j. Poich in tal caso la quantit da ordinare uguale al fabbisogno dei periodi da i a j-1:
d(i)+d(i+1)+...+d(j-1), il costo c(i,j) dato dal costo di rifornimento k pi il costo di mantenimento
hd(i+1)+2hd(i+2)+3hd(i+3)+.... In questo modo la lunghezza del cammino pi breve da 1 a n+1
corrisponde al costo minimo di gestione delle scorte e i nodi inclusi nel percorso ottimo
corrispondono agli istanti in cui si deve effettuare l'ordine. Il problema di gestione delle scorte pu
essere cos risolto in un numero di passi proporzionale al quadrato del valore dell'orizzonte n.
Per risolvere lo stesso problema tramite la Programmazione Dinamica conviene definire il costo
cumulato come il costo ottimo F(t) del il sottoproblema di orizzonte [t,n] e di scorte iniziali nulle. Il
valore di F(t), in conseguenza della propriet fondamentale, dipende solo dal tempo t, non dallo
stato x(t), e pu essere calcolato ricorsivamente:
F(i)=min
j
{c(i,j)+F(j)| j>i} (7.4)
In (7.4) il minimo relativo a solo n-i valori di j, quindi possibile determinare il costo ottimo
F(0) in un numero quadratico in n di operazioni. Il numero delle operazioni necessarie pu essere
anche minore, infatti la (7.4) implica F(i)k+F(i+1), dunque domande future molto elevate o molto
remote nel tempo, che comportano costi di mantenimento superiori al costo fisso di rifornimento,
devono essere escluse a priori dall'ordine attuale. Algoritmi di Programmazione Dinamica
particolarmente efficienti possono addirittura permettere di risolvere questo problema in un numero
di operazioni proporzionale a nlogn.
7.6 Esempio
Nei prossimi quattro giorni lavorativi la domanda prevista per un dato componente uguale a 51,
80, 24, 48. Il costo fisso di rifornimento di 75, mentre il costo di mantenimento unitario.
50
Assumendo di avere vuoto il proprio magazzino, si vuole determinare quando e quanto ordinare in
modo da minimizzare i costi e non andare sotto scorta.
Problema di scorte (formulazione canonica):
- orizzonte: t=1,2,3,4,5, T=5;
- stato x(t): livello delle scorte allinizio del periodo t (e quindi alla fine del periodo t-1);
X(1)={0}, X(t)=R
+
, per t=1,2,3,4, X(5)={0};
- controllo u(t): quantit ordinata all'istante t, supponendo che lordine sia emesso (ed eseguito)
prima della domanda, U(t)=R
+
, per t=1,2,3,4;
- variabili esogene z(t): domanda d(t), per t=1,2,3,4;
- funzione di transizione dello stato f(x,u,z,t): x(t+1)=x(t)-u(t)+d(t), per t=0,1,2,3,4;
- costo: g(x(t),u(t),t)=1x(t)+75(u(t)), per t=1,2,3,4;
con:

=
>
=
0 ) t ( u 0
0 ) t ( u 1
)) t ( u (
se
se
(7.5)
Determinare la sequenza ottima di controlli u*(t) che definiscono il costo minimo da 1 a 5.
Applicando l'equazione ricorsiva (7.4), si ottiene:
- F(5)=0;
- F(4)=min{75+F(5)}=75, quindi u(4)=48;
- F(3)=min{75+F(4),75+48+F(5)}=123, quindi u(3)=24+48=72;
- F(2)=min{75+F(3),75+24+F(4),75+24+248+F(5)}=164, quindi u(2)=80+24=104;
- F(1)=min{75+F(2),75+80+F(3),75+80+224+F(4),75+80+224+348+F(5)}=239, quindi
u(1)=51;
I risultati derivanti dal computo dei valori dell'equazione ricorsiva indicano che la politica ottima
consiste nell'ordinare il primo, il secondo e il quarto giorno. Il calcolo dei minimi corrisponde
banalmente a tenere conto che, se si emette un ordine nella quarta giornata, tutta la merce deve
essere consumata subito; viceversa, se si emette un ordine nelle giornate precedenti, si deve valutare
se conviene fare arrivare merce anche per i giorni successivi.
Si osservi, infine, che il calcolo di F(2) e F(1) stato riportato per esteso solo per motivi
didattici: il terzo argomento del minimo considerato nel calcolo di F(2) e gli argomenti dal secondo
in poi del minimo considerato nel calcolo di F(1) possono essere a priori scartati. Nel caso di F(2),
ad esempio, certamente inutile ordinare merce anche per la quarta giornata, infatti il costo di
mantenimento di tale merce per due giorni superiore al costo che si paga ordinandola
separatamente solo quando serve.
51
7.7 Domande ed esercizi
7.1 Si risolva il problema dell'esempio nel paragrafo 7.6 assumendo un orizzonte temporale di 10
giorni e la seguente domanda:
t 1 2 3 4 5 6 7 8 9 10
d(t) 37 29 52 54 63 42 32 21 25 34
7.2 Si risolva il problema dell'esempio nel paragrafo 7.6 assumendo un orizzonte temporale di 10
giorni, costo di rifornimento k=10 e la seguente domanda:
t 1 2 3 4 5 6 7 8 9 10
d(t) 7 19 12 14 6 12 12 11 15 14
Come conviene comportarsi quando i costi fissi sono molto bassi? E quando sono molto alti?
7.3 Si risolva il problema dell'esempio nel paragrafo 7.6 assumendo un orizzonte temporale di 10
giorni, costo di rifornimento variabile nel tempo e la seguente domanda:
t 1 2 3 4 5 6 7 8 9 10
d(t) 17 29 23 14 34 32 22 10 15 14
k 30 30 30 20 20 20 15 15 15 15
7.4 Si risolva il problema dell'esempio nel paragrafo 7.6 assumendo che le consegne arrivino
ritardate di due giorni dall'ordine, un orizzonte temporale di 10 giorni e la seguente domanda:
t 1 2 3 4 5 6 7 8 9 10
d(t) 14 29 22 25 33 46 22 11 15 14
Come deve essere modificata la procedure di soluzione?
7.5 Proporre una procedura di soluzione approssimata con cui affrontare l'esercizio 7.1 quando vi
siano dei limiti superiori sulla dimensione massima del lotto d'ordine. Si supponga ad esempio
che il lotto massimo non possa superare la dimensione di 60.