Sistemi Organizzativi

docente: Stefano Smriglio

stefano.smriglio@univaq.it

Pre-requisiti:
Classi di complessit
Programmazione Lineare (Intera)
Metodo branch-and-bound
Cammini minimi su grafi

Materiale didattico:
M. Pinedo, Scheduling (Systems, Models and Algorithms)
Prentice Hall
A. Agnetis, dispense http://www.dii.unisi.it/~agnetis/didattica
Trasparenti dalle lezioni http://www.di.univaq.it/~oil
Parte I:
Scheduling a macchina singola
 Indice

1. Introduzione: esempi, elementi di un problema di

scheduling, notazione. Formulazioni PLM, PLB

2. Problemi a macchina singola

1//wjCj algoritmo WSPT
1/chain/wjCj algoritmo polinomiale
1/prec/hmax algoritmo di Lawler
1/rj,prmp/Lmax regola preemptive EDD
1/rj/Lmax complessit, branch-and-bound
1//Uj algoritmo di Moore
1//hj Programmazione dinamica
1//Tj algoritmo pseudo-polinomiale
1//wjTj branch-and-bound
Introduzione

problemi di scheduling
esempi
classificazione
 Esempio
Silvia (S) e Francesca (F) giungono nello stesso
momento ad una macchina fotocopiatrice. F deve fare 1
fotocopia, S ne deve fare 100.
Il galateo imporrebbe a S di lasciar passare per prima F,
che ha un compito molto pi breve.
una buona idea?

Analisi. Supponiamo che lesecuzione di una fotocopia

richieda 3 secondi. Due casi:

S precede F F precede S
303 3

0 300 0 303
Attesa totale = 300 + 303 = 603 Attesa totale = 3 + 303 = 306
 Esempio

E se Francesca F arrivasse allistante rf?

S F
303
Attesa totale = 300 + 303 rf =
0 rf 300 = 603 rf

Di nuovo, il galateo imporrebbe a Silvia di interrompere le

proprie copie in favore di Francesca:

rf + 3
Attesa totale = 3 + 303 = 306
0 rf 303
 Ricapitolando

Attivit: 2 blocchi di fotocopie (di durata nota)

Risorse: una macchina fotocopiatrice
Vincoli:

Capacit: al pi una fotocopia alla volta

(caso 2) F non pu iniziare prima dellistante rf
Misura: attesa complessiva presso la macchina
fotocopiatrice

Rappresentazione di una soluzione: diagramma di Gantt

303
S F
0 300
 CPU scheduling

Il sistema operativo disciplina laccesso alla CPU dei

diversi programmi di calcolo.

tecnica time-sharing (Linux): il tempo di CPU suddiviso

in intervalli (definiti dal timer interrupt) e, in ogni intervallo,
possibile eseguire al pi un processo.

diversi obiettivi: rispondere prontamente a ciascun

processo, evitare interruzioni prolungate, evitare ritardi nei
processi pi urgenti.

Linux attribuisce dinamicamente una priorit ai processi.

Ad es., la priorit proporzionale allattesa del processo
 CPU scheduling

Attivit: programmi
Risorse: CPU
Vincoli: Capacit: al pi un programma in ciascun
intervallo per ciascuna CPU
Misure:
tempo massimo di attesa di un programma
tempo di completamento di tutti i programmi
ritardi nei processi urgenti
 Scheduling dei velivoli in atterraggio

La torre di controllo (ATC) ha il compito di assegnare

una pista ed un istante di atterraggio a ciascun velivolo
nel proprio campo radar (area terminale)

Ogni velivolo ha una finestra temporale [r,s] definita da

due istanti di atterraggio estremi, a seconda che il
velivolo viaggi:
- alla sua massima velocit (istante r)
- in modalit di minimo consumo (istante s)

Un velivolo in atterraggio impegna la pista per un

tempo noto ma genera turbolenza: quello successivo
deve attendere un tempo di separazione (funzione
delle dimensioni dei velivoli)
 Scheduling dei velivoli in atterraggio
Ad ogni velivolo associato un orario di atterraggio
predeterminato (e pubblicato nelle tabelle)
Limportanza di un velivolo dipende da fattori quali la
dimensione, la compagnia, la distanza percorsa

Attivit: atterraggi
Risorse: k piste
Vincoli:
Capacit: su ogni pista, al pi un atterraggio in un
certo istante
finestre temporali di atterraggio
separazione fra atterraggi consecutivi
Misura:
somma (pesata in base allimportanza) dei ritardi
rispetto allorario pubblicato
 Ancora nella vita quotidiana
Aldo (A), Bruno (B), Carlo (C), Duilio (D) condividono un
appartamento e, ogni mattino, ricevono 4 giornali:
Financial Times (FT), Guardian (G), Daily Express (DE),
Sun (S).
Ognuno ha i propri gustiinizia la lettura ad una certa
ora, legge i giornali nella sua sequenza preferita e
(ciascuno) per un tempo prefissato:

lettore inizio Sequenza giornali (min.)

Aldo 8.30 FT(60) G (30) DE (2) S(5)
Bruno 8.45 G(75) DE(3) FT(25) S(10)
Carlo 8.45 DE(5) G(15) FT(10) S(30)
Duilio 9.30 S(90) FT(1) G(1) DE(1)
 Ancora nella vita quotidiana

inoltre, ciascun lettore:

rilascia un giornale solo dopo averlo letto
completamente.

termina la lettura di tutti i giornali prima di uscire.

infine, i quattro lettori attendono che tutti abbiano

terminato di leggere prima di uscire di casa

Problema:

A che ora A, B, C, D riescono (finalmente!) ad

uscire?
 Interpretazione
lettore inizio Sequenza giornali (min.)
Aldo 8.30 FT(60) G (30) DE (2) S(5)
Bruno 8.45 G(75) DE(3) FT(25) S(10)
Carlo 8.45 DE(5) G(15) FT(10) S(30)
Duilio 9.30 S(90) FT(1) G(1) DE(1)

determinare in quale
A FT G B
sequenza ciascun
giornale accetta i
lettori in modo da
D S DE C minimizzare il tempo di
lettura totale.
 Soluzioni
lettore inizio Sequenza giornali (min.)
Aldo 8.30 FT(60) G (30) DE (2) S(5)
Bruno 8.45 G(75) DE(3) FT(25) S(10)
Carlo 8.45 DE(5) G(15) FT(10) S(30)
Duilio 9.30 S(90) FT(1) G(1) DE(1)

una possibile soluzione:

giornale Sequenza lettori

ESERCIZIO:
FT A D C B
valutare lora in cui A,B,C
G B C A D
e D escono di casa
DE C B A D
S D A C B
 ESERCIZIO: giornale Sequenza lettori
data la soluzione in tabella FT A D C B
valutare lora in cui A,B,C
G B C A D
e D escono di casa
DE C B A D
S D A C B
D
FT A C B
D
G B C A
B A D
DE C
A
S D C B
8.30 9.0
9.00 10.00 11.00
11.51
 Enumerazione totale

Il numero di soluzioni (4!)4 = 331.776

per un problema con n lettori e m giornali diventa (n!)m.

esaminando 10.000 soluzioni al secondo (4 giornali e n

lettori):

n tempo

5 354 min

10 2 1017
giorni
 In generale

Con il termine scheduling si indica lallocazione

temporale di risorse scarse ad attivit

Elementi di un problema di scheduling:

job: attivit da svolgere insieme J = {1,,n}
Fotocopia, esecuzione di un programma di calcolo
Un job pu rappresentare una singola attivit o un
insieme di attivit (task) tecnologicamente legate
macchine: risorse che eseguono le attivit insieme
M={1,,m}
Fotocopiatrice, CPU, giornali
 Attributi dei job

tempo di processamento pij durata del

processamento del job j sulla macchina i

release date rj tempo in cui j arriva nel sistema,

rendendosi disponibile al processamento

due date dj tempo entro il quale si desidera che il

job j sia completato (data di consegna)

peso wj indica limportanza del job j

 Classificazione

Il processamento di un job su una macchina detto

operazione.
I problemi di scheduling si classificano in base alle
caratteristiche dei task e allarchitettura delle
macchine

Notazione a tre campi: /

/:

descrive il sistema di macchine

rappresenta vincoli e modalit di processamento (0,
1 o pi componenti)
indica lobiettivo
 Campo
Macchina singola (1) : ciascun job richiede una singola
operazione da eseguirsi sullunica macchina disponibile
Macchine identiche parallele (Pm) : ciascun job richiede
una singola operazione da eseguirsi su una qualunque delle
m macchine identiche.

m
 Campo

Flow shop (Fm) : Ciascun job composto di m task,

ciscuno da eseguirsi su una macchina secondo una
sequenza fissata, uguale per tutti i job.

1 2 m

Job shop (Jm) : Ciascun job j composto di m(j) task,

ciscuno da eseguirsi su una macchina secondo una
sequenza fissata, dipendente da j
 Campo
Release dates (rj): il job j non pu iniziare il
processamento prima dellistante rj

Preemption (prmp): ammesso interrompere

unoperazione per iniziarne una nuova. Il processamento
eseguito prima dellinterruzione non va perso: quando
loperazione viene ripresa, essa richiede solo il tempo
rimanente di processamento

job 1 2 1 2 1
pj 3 4 1 5 7
schedule ammissibile
 Campo
prec: dato un grafo G = (N, A) diretto e aciclico che
rappresenta una relazione di precedenza fra job. Un job j
pu iniziare solo se tutti i suoi predecessori sono stati
completati

2 4

1
1 2 4 3 5

3 5
schedule non ammissibile

chain: caso speciale in cui ogni componente connessa

del grafo un cammino orientato (catena)
 Campo

Tempi di set-up (sjk): tempo richiesto per il

riattrezzaggio delle macchine fra i job j e k. Se dipende
dalla macchina i, si esprime con sijk

breakdown (brkdwn): le macchine non sono sempre

disponibili, ma hanno periodi fissati di interruzione del
servizio
 Definizioni
Cj tempo di completamento del job j

Lj = Cjdj lateness del job j

Tj = max(Lj,0) tardiness del job j

Uj = 1 se Cj>dj e 0 altrimenti

1 2
job 1 2 0 7 15
pj 7 8 C1= 7 C2= 15
dj 9 11 L1= 2 L2= 4
T1 = 0 T2 = 4
U1= 0 U2= 1
 Campo : funzioni obiettivo

Makespan (Cmax) : max (C1, , Cn) tempo di

completamento dellultimo job
Massima Lateness (Lmax) : Lmax =max (L1, , Ln)
Tempo totale pesato di completamento (wjCj)
o (weighted flow-time)
Tardiness totale pesata (wjTj)
Numero di tardy job (Uj)

tutte funzioni obiettivo regolari cio non-decrescenti

in C1, , Cn
 Esempio

job 1 2
wj 2 3
pj 7 8
dj 9 11

1 2
0 7 15

Lmax= 4 wjTj = 12
wjCj = 59 Uj = 1
 Sequenze e schedule

Si definisce sequenza una permutazione dei job

che definisce lordine con cui i job sono processati su
una certa macchina

Si definisce schedule un assegnamento di un

istante di inizio a ciascuno dei task di ogni job (se
prmp, istanti di inizio di ciascuna delle parti in cui
viene suddiviso un task)
 Schedule nondelay

uno schedule ammissibile detto nondelay se

nessuna macchina ferma quando esiste
unoperazione disponibile al processamento

In molti casi (sempre se prmp) le soluzioni ottime

sono nondelay. Ci non vero in generale
 ESERCIZIO: schedule nondelay

dato il seguente problema P2/prec/Cmax

2

1 10
job 1 2 3 4 5 6 7 8 9 10
3
pj 7 6 6 1 2 1 1 7 7 14

5 8

costruire uno schedule nondelay 6 7 9

e verificarne lottimalit
 ESERCIZIO: schedule nondelay
Soluzione nondelay:
M2 1 2 9
M1 46 5 7 8 3 10
32
0 10 20 30

Soluzione ottima:

M2 1 2 8 9

M1 46 5 7 3 10
27
0 10 20 30
fermo macchina forzato
1.1 Scheduling a macchina singola

Formulazioni di Programmazione Lineare

Booleana e Mista (PL(0-1)-PLM)
 Formulazione disgiuntiva

Variabili decisionali naturali:

t j Rn istante di inizio del job j, j = 1, , n

Macchina a capacit unitaria:

i precede j t j ti + pi valgono in
j precede i ti t j + p j alternativa !!

Variabili aggiuntive (binarie):

1 se i precede j

yij =
0 se j precede i

 Formulazione disgiuntiva (PLM)
i precede j yij = 1 t j ti + pi

j precede i yij = 0 ti t j + p j

Formulazione disgiuntiva

(1 yij )M + t j ti pi i, j J

yijM + ti t j pj i, j J

tj 0 j J
yij { 0,1} i , j J

M costante grande (quanto?)

 Problemi minsum: 1//j wjCj

min w (t
j J
j i + pi ) = w t +w p
j J
j j
j J
j j

(1 yij )M + t j ti pi i, j J

yijM + ti t j pj i, j J

tj 0 j J
yij { 0,1} i , j J

n2+n variabili
2n2 vincoli
 Esercizio

Formulare come problema di PLM la seguente istanza del

problema 1/rj/j wjCj

job 1 2 3
pj 3 1 2
rj 0 2 0
wj 3 2 4
Problemi minsum: 1//j wjTj

min w
j J
j max{ t j + p j d j ,0 }

(1 yij )M + t j ti pi i , j J

yijM + ti t j pj i, j J

tj 0 j J
yij { 0,1} i , j J
 RICHIAMO: Funzioni convesse lineari a tratti

c 3x + d3
max (c iT x + di )
c1x + d1 i =1,...,m

il pi piccolo valore z per cui

c 2 x + d2

x
z c iT x + di i = 1,..., m

min max (c iT x + di ) min z

i =1,...,m

Ax b Ax b
c iT x + di z i = 1,..., m
 Formulazione PLM

max{ t j + p j d j ,0 }

tj
0 dj pj

min w fj j

min w j max{t j + p j d j ,0} f j t j + pj dj , j J

j J

fj 0
 Formulazione PLM

min w f j j

f j t j pj dj , j J

(1 yij )M + t j ti pi i , j J

yijM + ti t j pj i, j J

tj 0 j J
yij { 0,1} i , j J
fj 0
 Problemi min-max: Lmax

min f

f t j pj dj , j J
(1 yij )M + t j ti pi i , j J

yijM + ti t j pj i, j J

tj 0 j J
yij { 0,1} i , j J
f 0
 Formulazioni Time-indexed
Orizzonte temporale [0,T] discretizzato in periodi di durata
unitaria. Il periodo t concide con lintervallo di [t 1, t]

Variabili binarie: xjt =1 se j inizia nel periodo t; 0 altrimenti

vincolo 1 (Completezza): ogni job inizia in un qualche t

T p j +1
x jt = 1, j = 1,..., n
t =1
j

j
j
j
1 2 3 4 5 Tpj
 Formulazioni Time-indexed

vincolo 2 (Capacit): al pi un job processato nel periodo t

un job occupa il periodo t se inizia nellintervallo [t pj+1, t]

j
j
j

t
quindi:
n min( t ,T p j + 1 )

j =1
x js
s = max( 1 , t p j + 1 )
1, t = 1,..., T
 Formulazione PL(0-1)
n T p j +1
min
j =1
c jt x jt
t =1
cjt costo di assegnazione
del job j allistante t

T p j +1
x jt = 1, j = 1,..., n
t =1
n min( t ,T p j + 1 )

j =1
x js
s = max( 1 , t p j + 1 )
1, t = 1,..., T

x jt { 0,1}, j = 1,...,n; t = 1,...,T p j + 1

nT variabili; n + T vincoli
 Funzioni obiettivo (min-sum)

se j inizia nel periodo t si ha Cj = t+pj1

t t+pj1

tempo totale di completamento:

n T p j +1 n
cjt = wj(t+pj1) w (t + p
j =1 t =1
j j 1)x jt = w jC j
j =1

tardiness totale:
c jt = w j max{ 0, t + p j d j 1}
n T p j +1 n

w
j =1 t =1
j max( 0, t + p j d j 1)x jt = w T
j =1
j j
 Esercizio

Formulare come problema di PL(0-1) la seguente istanza

del problema 1/rj/j wjCj

job 1 2 3
pj 3 1 2
rj 0 2 0
wj 3 2 4
 Vincoli di precedenza

vincolo 3 (Precedenza ij): se il job i non iniziato nei

periodi 1,2,,t allora il job j non pu iniziare nei periodi 1,
2,, t + pi

j
i

t
quindi:
t + pi t

x
s =1
js x
r =1
ir , t = 1,..., T pi p j + 1
1.2 Tempo totale pesato di completamento

w jC j
 nondelay schedule

Propriet 0.1 Dato un problema del tipo 1// con

funzione obiettivo regolare, esiste uno schedule
ottimo in cui la macchina processa ininterrottamente
dallistante 0 allistante Cmax= pj
 Tempo totale pesato di completamento
1// wjCj
Definiamo Weighted Shortest Processing Time
(WSPT) una regola che ordina i job per valori non
crescenti del rapporto wj/pj

Sussiste il seguente

Teorema 1.1 La regola WSPT calcola una soluzione

ottima del problema 1//wjCj

Dimostrazione. (Per contraddizione)

Assumiamo che S sia uno schedule ottimo e che non
rispetti WSPT
 Dimostrazione
Allora devono esserci in S due job adiacenti, diciamo j
seguito da k tali che

wj/pj < wk/pk

Assumiamo che il job j inizi allistante t.

Eseguiamo uno scambio dei job j e k ottenendo un
nuovo schedule S'

S j k
t+pj

S k j
t+pk
t
t+pj+pk
 Dimostrazione
S j k

S k j

t t+pj+pk

Il tempo totale (pesato) di completamento dei job che

precedono e seguono la coppia (j,k) non modificato
dallo scambio. Il contributo dei job j e k in S :

(t+pj)wj + (t+pj+pk)wk
mentre in S' :

(t+pk)wk + (t+pk+pj)wj
 Dimostrazione
in S] (t+pj)wj + (t+pj+pk)wk

in S'] (t+pk)wk + (t+pk+pj)wj

Eliminando i termini uguali:

in S] pjwk

in S'] pkwj

Quindi, se wj/pj < wk/pk, risulta pk wj < pj wk, cio il

tempo totale pesato in S' strettamente inferiore a quello
in S, contraddizione
 Vincoli di precedenza
1/prec/ wjCj

Nel caso generale il problema NP-Hard.

Consideriamo invece il caso in cui le precedenze sono
rappresentate da un insieme di catene in parallelo:
1/chain/wjCj

Per questo caso esiste un algoritmo di soluzione polinomiale.

 Catene non interrompibili
Date due catene:
12k
k+1 k+2 n

Minimizziamo wjCj con il vincolo che i job di ciascuna

catena debbano essere processati consecutivamente.

Lemma 1.2 Se k n
wj wj
j =1 j =k +1
k
> n
pj pj
j =1 j =k +1

allora la catena 1, ,k precede la catena k+1, , n

 Dimostrazione
Per la sequenza 1,2,,k,k+1,k+2,,n (S1) il tempo totale
di completamento
k k n
w1 p1 + K + wk p j + wk +1( p j + pk +1 ) + K + wn p j
j =1 j =1 j =1

Per la sequenza k+1,k+2,,n,1,2,,k (S2) il tempo totale

di completamento

n n n
wk +1pk +1 + K+ wn pj + w1( pj + p1) + K+ wk pj
j =k +1 j =k +1 j =1
 Semplificando
S1
k k n k
w k +1 p j + K + w n p j = ( w j )( p j )
j =1 j =1 j = k +1 j =1
S2
n n k n
w1 p j + K + wk p j = ( w j )( p j )
j =k +1 j =k +1 j =1 j =k +1

Quindi, ricordando lipotesi:

k n

w j w j n k k n
j =1
k
> j = k +1
n
( w )( p j j ) < ( w j )( p j )
p p
j = k +1 j =1 j =1 j = k +1
j j
j =1 j = k +1
cio, S1migliore di S2
 Coefficiente di una catena

Lidea chiave dellalgoritmo ricondurre

1/chain/wjCj al problema di sequenziare catene
non-interrompibili, in modo da utilizzare il Lemma 1.2.

Definizione 1.3 Data una catena 1 2 k

definiamo coefficiente della catena il seguente
rapporto:
l*
l

wj wj
max j =1
j =1
(1,K,k ) = l * =
pj
1 l k l

pj
j =1 j =1
 Esempio
job 1 2 3 4
pj 3 4 2 6
wj 10 4 17 8

1 2 3 4

l w
max j =1 j
(1,K,4) = l = , , ,
10 14 31 39
1 l 4 p 3 7 9 15
j
j =1
l* = 3
 Propriet del coefficiente

Propriet 1.4 Se un job l* determina il coefficiente

(1,...,k) allora per qualunque 1<u<l* risulta:

l* u
wj wj
j =u +1 j =1
l*
> u
pj pj
j =u +1 j =1
 Dimostrazione
l* u
Per definizione: wj wj
j =1 j =1
l*
> u
pj pj
j =1 j =1
da cui:
l* l* u u
p1 w j + K + pu w j > p1 w j + K + pl * w j
j =1 j =1 j =1 j =1

l* l* u u
p1 w j + K + pu w j > pu +1 w j + K + pl * w j
j =u +1 j =u +1 j =1 j =1
u l* l* u
( p j )( w j ) > ( p j )( w j )
j =1 j = u +1 j = u +1 j =1
 Propriet dello schedule ottimo

Lemma 1.5 Si consideri una generica catena (1, ..., k) e

sia l* il job che determina il suo coefficiente (1,...,k).
Allora esiste uno schedule ottimo che processa i job 1, ,
l* consecutivamente.

Dimostrazione. (per contraddizione) Assumiamo che in una

sequenza ottima la sequenza 1,,l* sia interrotta da un job
v (1,...,k), cio, contenga la sottosequenza

(S) 1,,u,v,u+1,l*
 Propriet dello schedule ottimo

(S) 1,,u,v,u+1,l*.

Consideriamo le sottosequenze:

(S') v,1,,u,u+1,,l*

(S'') 1,,u,u+1,l*,v

Mostriamo che per almeno una fra S' e S'' il tempo di

completamento non superiore a quello di S.
 Dimostrazione
Applicando il Lemma 1.2 alle catene (v) e (1,,u) si ha che
se il valore (wjCj) di S inferiore a quello di S', allora:

wv w1 + w2 + K + wu
<
pv p1 + p2 + K + pu

Applicando il Lemma 1.2 alle catene (v) e (u+1,,l*) si ha

che se il valore (wjCj) di S inferiore a quello di S'', allora:

wv wu +1 + wu + 2 + K + wl *
>
pv pu +1 + pu + 2 + K + pl *
 Dimostrazione
Per la Propriet 1.4 risulta inoltre:

wu +1 + wu + 2 + K + wl * w1 + w2 + K + wu
>
pu +1 + pu + 2 + K + pl * p1 + p2 + K + pu

Quindi, se S meglio di S'', allora:

wv wu +1 + wu +2 + K + wl * w1 + w2 + K + wu
> >
pv pu +1 + pu +2 + K + pl * p1 + p2 + K + pu

Contraddizione (avendo assunto S meglio di S'). Lo stesso

argomento si applica quando la catena interrotta da
molteplici job.
 Algoritmo

I due lemmi precedenti sono il fondamento di un algoritmo

polinomiale:

Algoritmo 1.6
In ogni istante in cui la macchina libera, seleziona fra le
rimanenti catene quella con il massimo coefficiente e la
processa senza interruzione fino al job che definisce
(incluso)

Lalgoritmo ha complessit O(n2)

 Esempio
job 1 2 3 4 5 6 7
wj 6 18 12 8 8 17 18
pj 3 6 6 5 4 8 10

1 2 3 4

5 6 7
step1.
(1,2,3,4) = (6+18)/(3+6) = 24/9, l*=2

(5,6,7) = (8+17)/(4+8) = 25/12, l*=6

1 2
 Esempio

job 1 2 3 4 5 6 7 3 4
wj 6 18 12 8 8 17 18
pj 3 6 6 5 4 8 10 5 6 7

step2.
(3,4) = 12/6, l*=3

(5,6,7) = (8+17)/(4+8) = 25/12, l*=6

1 2 5 6
 Esempio

job 1 2 3 4 5 6 7 3 4
wj 6 18 12 8 8 17 18
pj 3 6 6 5 4 8 10 7

step3.
(3,4) = 12/6, l*=3

(7) = 18/10, l*=7

1 2 5 6 3
 Esempio

job 1 2 3 4 5 6 7 4
wj 6 18 12 8 8 17 18
pj 3 6 6 5 4 8 10 7

step4.
(4) = 8/5, l*=4
(7) = 18/10, l*=7

1 2 5 6 3 7 4
 Release date e preemption

Lintroduzione delle release date complica il problema. Nel

caso in esame, il problema 1/rj/wjCj NP-hard. [Ex1]

Richiamo. Dato un problema di ottimizzazione P =(z,S) (di

minimo), si definisce rilassamento di P un nuovo problema
RP=(w,) tale che:

(i) S
(ii) x S risulta w(x) z(x)
 Rilassamento preemptivo

Il problema1/rj, prmp/wjCj si dice rilassamento (perch

lo ?) preemptivo.

Per esso interessante valutare il comportamento della

naturale estensione della regola WSPT:

Preemptive WSPT: in ogni istante (intero) di tempo, si

processa il job disponibile con il massimo rapporto

peso / tempo residuo di processamento

 Esempio

job 1 2 3 4 5
wj 1 4 3 5 3
pj 2 3 3 2 1
rj 0 2 3 1 4

15 28 33

1 4 4 2 5 2 2 1 3 3 3

15 8

ZPWSPT=99
 PWSPT non ottima per
1/rj ,prmp / wj Cj

2 108

1 1 2 2 2 2 2 2 2 2 2 2 3 3
job 1 2 3
112
wj 1 9 8 ZPWSPT=222
pj 2 10 2
rj 0 1 11
99 104

1 2 2 2 2 2 2 2 2 2 2 3 3 1
14
ZOPT=217
 Complessit

PWSPT si esegue in tempo O(n log n)

Si mantiene la lista ordinata per valori decrescenti del

rapporto wj/pj(t) e la lista ordinata dei job per release date
crescenti.

Gli eventi significativi sono di due tipi: (i) completamento di un

job e (ii) rilascio di un nuovo job. Quindi, ci sono O(n) eventi.

In corrispondenza di ciascun evento si deve:

aggiornare la lista, richiede tempo O(log n)
calcolare levento successivo, calcolando min(t + pj(t), rj1),
che richiede tempo costante
 Pesi unitari
Nel caso di pesi tutti unitari PWSPT schedula, in ogni
istante (intero) di tempo, il job disponibile con il minimo
tempo residuo di processamento (Shortest Remaining
Processing Time, SRPT)

Si ha il seguente:

Lemma 1.6
La regola SRPT ottima per 1/rj, prmp/Cj

Dimostrazione. Mostriamo che, comunque preso uno

schedule S che non rispetta SRPT, ne esiste uno S' che la
rispetta con un tempo di completamento non peggiore.
 Dimostrazione
Se S non rispetta SRPT, deve esserci un istante t in cui
processata una unit del job j pur esistendo k tale che

pj(t) > pk(t)

Costruiamo un nuovo schedule S' in cui le rimanenti pk(t) unit

del job k sono scambiate con le prime pk(t) del job j.

S j k

S k
t t'
 Dimostrazione

S j k

S k
t t'
i job diversi da j e k non subiscono alcuna variazione;
primo caso: Ck(S ) > Cj(S )
Essendo pj(t) > pk(t) si ha che Ck(S ) Cj(S);
inoltre, per costruzione, Cj(S ) = Ck(S );
Quindi: Ck(S ) + Cj(S ) Ck(S ) + Cj(S )
 Dimostrazione

S j k

S k
t t'

secondo caso: Ck(S) < Cj(S)

Ck(S ) Ck(S);
Cj(S ) = Cj(S);
Quindi: Ck(S) + Cj(S ) Ck(S) + Cj(S )
Esercizi
 Esercizio 1

Dimostrare che la regola SPT non ottima per il problema

1/rj/ Cj

z(SPT) = 12

1 2
job 1 2 3 4 8
rj 3 0
pj 1 4

1 z(OPT) = 9
2
1 4 5 5
 Esercizio 2
Dimostrare che la regola WSPT non ottima per il
problema 1/brkdwn/ wj Cj

z(WSPT) = 85

1 2
job 1 2 1 2 3 4 5
wj 10 15
10 75
pj 1 2

1 z(OPT) = 70
2
1 2 3 4 5
30 40
 Esercizio 3
Dimostrare o confutare che la regola SPT ottima per il
problema 1/brkdwn/ Cj

job 1 2 3
pj 3 2 4
z(SPT) = 22

2 1 3
2 4 5 8 12

z(OPT) = 21

3 2 1
4 5 7 10
1.3 Problemi min-max
(Massima Lateness Lmax)
 1/prec/hmax

Forma della funzione obiettivo:

hmax = max (h1(C1), , hn(Cn))

hj(Cj) una arbitraria funzione non decrescente di Cj

Esempi:
hj(Cj)= Cj dj = Lj hmax = Lmax
hj(Cj) = max (0,Lj) = Tj hmax = Tmax

Precedenza: GP generico grafo aciclico.

Dato che le soluzioni ottime sono nondelay, lultimo job

termina allistante C max = nj=1 p j
 Algoritmo di Lawler
Costruisce lo schedule a partire dal fondo
J job gi schedulati nellintervallo [C max j J p j ,C max ]
Jc = {1, , n} \ J
J job schedulabili immediatamente prima di J (= tutti i
successori sono in J)

Inizializzazione:
J = , Jc = {1, , n}, J insieme dei job privi di successori

Loop: while (Jc )

Schedula in ultima posizione il job j* tale che
h j * ( p j ) = min (h j ( p j ))
j J c j J j J c

J := J {j*}, Jc := Jc \{j*}, aggiorna J

Endloop.
 Corretezza

Teorema 1.7 Lalgoritmo di Lawler restituisce uno

schedule ottimo per 1/prec/hmax

Dimostrazione. (Per contr.) Sia S una sequenza ottima

per cui, ad una generica iterazione, selezionato il job
J ma esiste j* (schedulabile) tale che
j**

h j * ( p j ) < h j ** ( p j )
j J c j J c

S j* j** J

Quindi, j* schedulato prima di j**

 Dimostrazione (continua)
hj ** hj **

hj * hj *

j* j** j** j*

S S

Consideriamo un nuovo schedule S ottenuto da S spostando

il job j** subito dopo j*. [Lunico job che peggiora j*]
 Dimostrazione (continua)
hj ** hj **

hj * hj *

j* j** j** j*
S S
h j * ( p j ) < h j ** ( p j ) costo di j* in S inferiore al costo di
c c
jJ jJ
j** in S. Quindi S meglio di S, contraddizione.
 Esempio
Gp
job 1 2 3 4
pj 3 4 2 6
(C4/5)
4 2
hj 10 1+C2 1.5 C3 2
Iter 1.
p j = 15
j J c

J
job 1 2 3
Jc {1,2,3,4}
costo 10 16 22.5
J {1,2,3}

1
0 12 15
 Esempio

job 1 2 3 4 Gp
pj 3 4 2 6
hj 10 1+C2 1.5 C3 2 (C4/5) 4 2

Iter 2.
p j = 12
j J c

J {1} job 2 3
Jc {2, 3,4} costo 13 18
J {2,3}

2 1
0 8 12 15
 Esempio
job 1 2 3 4
pj 3 4 2 6
hj 10 1+C2 1.5 C3 2 (C4/5)

Iter 3. pj = 8
j J c

J {1,2}
job 3 4
Jc {3,4}
costo 12 3.03
J {3,4}

S* 3 4 2 1
0 2 8 12 15

z(S*) = max(10, 13, 3.03, 3)

 Algoritmo di Lawler: caso speciale

Lalgoritmo di Lawler si esegue in tempo O(n2)

Infatti, assumendo che il calcolo del valore delle funzioni hj

richieda tempo costante, lalgoritmo richiede n passi,
ciascuno basato su n confronti

Nel caso 1//Lmax lalgoritmo di Lawler si specializza:

h j (C j ) = C j d j

min (h j ( c p j )) = max (d j )
j J j J j J

Equivale alla regola EDD (Earliest Due Date)

 Esercizio
Dimostrare che la regola EDD non ottima per il problema
1// Lj

Controesempio:

job 1 2 3
pj 3 4 2
dj 6 4 5

2 3 1 4
0 4 6 9
3 1 2 1
0 2 5 9
 1/rj/Lmax: complessit

Teorema 1.8 1/rj /Lmax NP-hard in senso forte

Dimostrazione. Riduzione polinomiale da 3-PARTITION

3t
Istanza: interi a1, ,a3t ,b tali che b/4<aj<b/2, a j = tb
j =1
Problema: partizione in t terne tutte di peso b?

Costruiamo la seguente istanza di 1/rj/Lmax con n = 4t1

rj =jb + (j1), pj=1, dj=jb +j, j =1,,t1

rj = 0, pj = ajt+1, dj =tb + (t 1), j =t,,4t1

Problema (target): uno schedule di valore z 0?

 1/rj/Lmax : complessit

rj=jb+(j1), pj=1, dj=jb+j, j=1,,t1

schedule con Lmax z =0 se e solo se ogni job j, j

=1,,t 1, processato fra rj e dj = rj+pj

r1 d1 r2 d2 r3 d3 rt 2 dt-2 rt1 dt 1
b

0 b b+1 2b+1 3b+2

tb+t 1
2b+2 3b+3

Fissando i primi t1 job bloccanti, rimangono t

intervalli di lunghezza b
 1/rj/Lmax : complessit

r1 d1 r2 d2 r3 d3 rt-2 dt-2 rt-3 dt-3

0 b b+1 2b+1 3b+2 tb+t1

2b+2 3b+3

schedule con Lmax 0 se e solo se i restanti 3t job:

rj = 0, pj =aj-t+1, dj=tb +(t 1), j =t,,4t1

per cui vale: 4 t 1 4 t 1

p = a
j =t
j
j =t
j t +1 = tb

possono essere schedulati negli t intervalli di lunghezza b.

 1/rj/Lmax : complessit
rj = 0, pj =aj-t+1, dj=tb +(t 1), j=t,,4t1

r1 d1 r2 d2 r3 d3 rt 2 dt2 rt3 dt3

b

0 b b+1 2b+1 3b+2 tb+t1

2b+2 3b+3

Essendo b/4<aj , in ciascun intervallo di lunghezza b non

entrano pi di tre job
4t 1 4t 1
essendo aj<b/2 e p j = a j t +1 = tb
j =1 j =1
mettendo meno di tre job in un intervallo, almeno un job
schedulato in ritardo
 1/rj/Lmax : complessit

rj = 0, pj =aj-t+1, dj=tb +(t 1), j=t,,4t1

r1 d1 r2 d2 r3 d3 rt-2 dt-2 rt-3 dt-3

0 b b+1 2b+1 3b+2

tb+t-1
2b+2 3b+3

Quindi, i job t,, 4t1 possono essere schedulati negli t

intervalli di lunghezza b sse possono essere suddivisi in t
terne di lunghezza b, cio, sse 3-PARTITION ha soluzione
 Esercizio

Risolvere la seguente istanza di 3-partition:

A={27,27,29,33,33,33,35,35,35,37,37,39}
b=100
 1/rj,prmp/Lmax

Preemptive EDD: ad ogni istante t, si processa il job

disponibile con la minima due date

R(t) = {j: rj t} insieme dei job disponibili al tempo t

Teorema 1.9 La regola PEDD calcola una soluzione

ottima del problema 1/rj, prmp/Lmax.

Dimostrazione. Consideriamo uno schedule S che viola

PEDD:
Al tempo t schedulato un job k R(t) per cui esiste un
job j
R(t) disponibile e non ancora terminato
tale che dk > dj
 PEDD - correttezza
Poich j non terminato, istante t > t in cui j in
esecuzione

S k j
t t+1 t t + 1
dk > dj

Consideriamo il nuovo schedule S ottenuto da S

scambiando j e k nei due intervalli di figura:

S j k
t t+1 t t +1
Il contributo dei job diversi da j e k non cambia
 PEDD - correttezza

S k j
t t+1 t t + 1
dk > dj
S j k
t t+1 t t + 1
Definiamo Cj e Ck i tempi di completamento di j e k nello
schedule S.
Dimostriamo che Lmax(S ) Lmax(S). Tre casi:

1. C j > t + 1, Ck > t + 1
2. C j = t + 1, Ck > t + 1
3. C j t + 1, Ck < t + 1
 PEDD - correttezza

caso 1. C j > t + 1, Ck > t + 1

S k j
t t+1 t t + 1

S j k
t t+1 t t + 1

Poich entrambi i job terminano dopo t+1 lo scambio

non ha alcun effetto: Lmax(S ) = Lmax(S)
 PEDD - correttezza

caso 2. C j = t + 1, Ck > t + 1

S k j
C j = t + 1

S j k
t t+1 t t + 1

Essendo Ck > t+1 il tempo di completamento di k in S

rimane inalterato; al contrario, quello di j diminuisce.
Quindi, Lmax(S )Lmax(S)
 PEDD - correttezza

caso 3. C j t + 1, Ck < t + 1

S k j

S j k
t t+1 t t + 1
Il tempo di completamento di k aumenta fino a t+1.
La lateness di k in S , quindi, pari a:

dk>dj t + 1 dk < t + 1 d j C j d j = L j
ed quindi inferiore alla lateness di j in S
 1/rj/Lmax

Algoritmo branch-and-bound
 Branch-and-bound: nozioni di base

Dato un problema di ottimizzazione

combinatoria: P0=(z, S)

z* = min {z(x) : x S}

S ={x1, , xm}
 Enumerazione totale
Algoritmo banale:

1. Enumera tutte le soluzioni ammissibili (sono in

numero finito) e calcolane il costo
2. Scegli la soluzione di costo minimo

Sfortunatamente questo algoritmo pu essere usato solo

quando il numero di soluzioni ammissibili non elevato.

Ad esempio, il numero di schedule ammissibili per un

problema a macchina singola (senza precedenze) n!
Quindi, per un problema con 20 job, eseguendo una
valutazione in 109 sec, impiegheremmo pi di 77 giorni
 Decomposizione

Proposizione1. Sia {S1,,Sp}, una decomposizione dellinsieme

S in sottoinsiemi

Si S per i = 1, , p.

i=1, ..., p Si = S
sia zi* il valore ottimo del sottoproblema (Si, c), i = 1,, p.
Allora,

z* = mini = 1,,p zi*

Osservazione: i sottoinsiemi non costituiscono

necessariamente una partizione di S
 Albero di enumerazione
applichiamo ricorsivamente il procedimento:

Nodo radice
Esempio: S
S = {0,1}3 x1=0 x1=1

S0 S1

x2=0 x2=1 x2=0 x2=1

S00 S01 S10 S11

x3=0 x3=1 x3=0 x3=1 x3=0 x3=1 x3=0 x3=1

S000 S001 S010 S011 S100 S101 S110 S111

Caso peggiore: 2n foglie + 2n 1 nodi intermedi

 Potatura
Il metodo branch-and-bound si basa sullidea di ridurre il pi
possibile il numero di sottoproblemi valutati (= per cui si risolve
il rilassamento lineare)

Diversi criteri, basati sulla soluzione di un rilassamento, ci

permettono di potare un sottoproblema (Si, c), cio di NON
procedere allesplorazione del sottoalbero di radice (Si, c)

Si
 Limitazioni inferiori di zi*
Proposizione 1. Sia S = S1 S2 Sp una
decomposizione della regione ammissibile S in p insiemi.

Sia z*i = min {cTx : x Si} .

Se ziLB un lower bound per il valore ottimo z*i

Allora,
zLB = mini ziLB un lower bound per z*

S
z LB= 5
S1 S2 S3

z 1LB= 10 z 2LB= 5 z 3LB= 7

 Soluzioni ammissibili: limitazioni superiori di
zi*
Proposizione 2. Sia S = S1 S2 Sp una decomposizione
della regione ammissibile S in p insiemi.

Sia z*i = min {cTx : x Si} e x i Si (soluzione ammissibile)

naturalmente, ziUB = cT xi un upper bound per il valore ottimo z*i

Allora,

zUB = mini ziUB un upper bound per z*

S
z UB= 9
S1 S2 S3

z 1UB= 15 z 2UB= 9 z 3UB= 13

 Potatura per bound
Sia z UB = c T x un upper bound del valore ottimo z*
Sia ziLB un lower bound per il valore ottimo z*i di (Si, c)

Se

LB
zi
LB UB
zi z z UB

z*

allora Si non contiene soluzioni ammissibili migliori di x

e il sottoproblema (Si, c) potato
 Calcolo di ziLB
Dato un problema di ottimizzazione P=(z,S) (di minimo),
si definisce rilassamento di P un nuovo problema
RP=(w,) tale che:
(i) S
(ii) x S risulta w(x) z(x)

Il calcolo di ziLB si effettua risolvendo in modo esatto

un opportuno rilassamento di (z,Si).
La scelta del rilassamento si basa su due esigenze,
spesso contrastanti:
o Ottenere buone approssimazioni di zi*
o Richiedere tempi di calcolo non elevati
 Potatura per ottimalit

Pu accadere che risolvendo il rilassamento si ottenga

una soluzione ottima del sottoproblema.

In questo caso, ovviamente, il sottoproblema

non va ulteriormente suddiviso.

Se z = w, ogni soluzione ammissibile di RP che sia

anche ammissibile per P, anche ottima per P.
 Branch-and-bound per 1/rj/Lmax
branching: al livello h dellalbero di enumerazione si fissa
in tutti i modi possibili il job in posizione h

----- radice: nessun job fissato

1-- 2-- n--

1, 2 - - 1, n - - n, 1 - - n, n-1 - -

Livello n : n! sottoproblemi
 Vincoli di branching: schedule parziali
Un sottoproblema S(k1) al livello k1 contiene
linsieme delle schedule in cui le prime k1 posizioni
sono assegnate

j1 , , jk1 schedule parziale

0 t
Un vincolo (di
branching) fissa un
certo job jk nella k-ma
posizione

j1 , , jk1 jk j1 , , jk1 jk
0 t 0 t
 Calcolo di ziLB

Rilassamento preemptivo: 1/rj,prmp/Lmax

la regola PEDD ottima (ed efficiente)

j1 , , jk1

j1 , , jk1 jk j1 , , jk1 jk

lower bound (livello k):

- eredita dal nodo padre
LB LB
- ricalcola, essendo z k 1 zk
 Dominanza fra sottoproblemi
Consideriamo uno schedule parziale al livello k-1: il
sottoproblema j1, , jk-1 , jk deve essere generato solo se:

r jk < min (max(t ,rl ) + pl ) = max(t ,rl * ) + pl *

l J

j1 , , jk1

j1 , , jk-1 jk
0 t rjk

altrimenti si otterrebbe un sottoproblema dominato da:

j1 , , jk-1 l* jk
0 t rjk
 branch-and-bound

Caso 1: potatura per Bound

Inizializzazione
Sia ziLB il valore ottimo di RP.
L={S}, zUB = +
Se ziLB zUB elimina Si , vai a Test

STOP
Test: L = ? Caso 2: potatura per Ottimalit
zUB Se la soluzione ottima xiUB di RPi
ottima anche per Pi, allora elimina Si.

Scegli un problema Si Aggiorna ottimo corrente:

dalla lista Se ziUB < zUB allora zUB =ziUB, vai a Test

Risolvi il Rilassamento Genera ed aggiunge ad L

su Si
i figli di Si corrispondenti a
schedule parziali ammissibili e
non dominati di Si
 Esercizio

job 1 2 3 4 1
pj 4 2 6 5 2
rj 0 1 3 5 3
dj 8 12 11 10 4

nodo radice:

-4 0 4 5

1 3 4 3 2
4 5 10 15 17

zLB(----) = 5
 Branching
job 1 2 3 4 ottimo corrente: (1,2,3,4)
pj 4 2 6 5
z =7
rj 0 1 3 5
dj 8 12 11 10

---- 5

1--- 2 --- 3 --- 4 ---

r3 > r2 + p2 r4 > r2 + p2
Eliminati per dominanza
 Valutazione di (1 - - -)

job 1 2 3 4
pj 4 2 6 5
rj 0 1 3 5
dj 8 12 11 10

-4 0 4 5

1 3 4 3 2
4 5 10 15 17
zLB(1,---) = 5
 Valutazione di (1 - - -)
-4 0 4 5

1 3 4 3 2
4 5 10 15 17
zLB(1,---) = 5

la condizione di potatura per bound fallisce

---- 5 7

5 1---
2 ---

12-- 13-- 14--

 Valutazione di (1 2 - -)

job 1 2 3 4
pj 4 2 6 5
rj 0 1 3 5
dj 8 12 11 10

-4 -6 -1 6

1 2 4 3
4 6 11 17
zLB(1,2--) = 6 Soluzione ammissibile z =6
 Valutazione di (1 2 - -)
-4 -6 -1 6

1 2 4 3
4 6 11 17
zLB(1,2--) = 6

sottoproblema potato per ottimalit

---- 5 7 6

5 1---
2 ---

6 6
1243 13-- 14--
 Valutazione di (1 3 - -)

job 1 2 3 4
pj 4 2 6 5
rj 0 1 3 5
dj 8 12 11 10

-4 -1 5 5

1 3 4 2
4 10 15 17
zLB(1,3--) = 5 Soluzione ammissibile z =5
 Arresto
6 5
---- 5

5 1---
2 ---

1243 1342 14--

6 6 5 5

Soluzione ammissibile di valore pari al lower bound globale: ottima

 Scelte implementative

Riassumendo, limplementazione di un branch-and-

bound consiste delle seguenti scelte:

regola di branching
rilassamento
regole di dominanza
strategia di visita dellalbero di enumerazione
(selezione del nuovo sottoproblema da valutare)
euristiche (in particolare al nodo radice)
 Esercizio
Calcolare la soluzione ottima del seguente problema
1/prec/wjCj
Regola di selezione del sottoproblema FIFO (visita in
ampiezza)

job 1 2 3 4 5

wj 1 4 1 6 3
pj 3 7 1 5 4

1 2 3
Grafo delle precedenze

4 5
 Valutazione di (-, -, -, -, -)
1 2 3

(1,2,3*)=max(1/3,5/10,6/11)=6/11

4 5 (4*,5) = max(6/5, 9/9)=6/5

(5)=3/4

4 5 1 2 3 zLB= 165
5 9 12 19 20
Soluzione del rilassamento chain: non ammissibile (5 precede 2)

1 2 3 4 5

3 10 11 16 20

Soluzione iniziale z = 210

 Branching al nodo radice

zUB= 210

----- zLB= 165

1---- 4----

Lista dei problemi candidati: {(1, - - - -), (4, - - - -)}

 Valutazione di (1, -, -, -, -)
job 1 2 3 4 5
wj 1 4 1 6 3
2 3
pj 3 7 1 5 4

(2,3*) = max(4/7, 5/8)=5/8

4 5
(4*,5) = max(6/5, 9/9)=6/5
(5) = 3/4

1 4 5 2 3

3 8 12 19 20

L= 183 5 precede 2: soluzione non ammissibile

 Branching
zUB= 210
----- zLB = 165

zLB = 183 1---- 4----

12--- 14---

Lista dei problemi candidati: {(1, 2, - - -), (1, 4, - - -), (4, - - -)}
 Valutazione di (4, -, -, -, -)

1 2 3

(1, 2,3*) = max(1/3, 5/10,

6/11)=6/11
5 (5) = 3/4

4 5 1 2 3

5 9 12 19 20

L= 165 5 precede 2: soluzione non ammissibile

 Branching

zUB= 210
----- zLB = 165

zLB = 183 1---- 4---- zLB = 165

12--- 14---
41---

Lista dei problemi candidati: {(1, 2, - - -), (1, 4, - - -), (4, 1 - -)}
 Valutazione di (1, 2, -, -, -)

3
(3) = max(1/1)= 1
(4*,5) = max(6/5,9/9)=6/5
4 5

Soluzione del rilassamento chain: ammissibile

1 2 4 3 5
3 10 15 16 20

aggiornamento dellottimo corrente zLB = 209 = zUB

 zUB= 210 zUB= 209

----- zLB = 165

L= 183 1---- 4---- L= 165

12--- (1, 2, 4, 3, 5) 14---

41---
zUB= 209

potato per ottimalit

Lista dei problemi candidati: {(1, 4, -, - -), (4, 1, -, - -)}

 Valutazione di (1, 4, -, -, -)

2 3 Solo il job 2 schedulabile:

lunico figlio (1 4 2 - -)

Valutazione di (1, 4, 2, -, -)

3 5 (3) = max(1/1)= 1 (5) =3/4

1 4 2 3 5
3 8 15 16 20

Soluzione del rilassamento chain: ammissibile L= 187

 zUB= 209 zUB= 187

----- zLB = 165

L= 183 1---- 4---- L= 165

12--- (1, 2, 4, 3, 5) 14---

41---
zUB= 209

potato per ottimalit 14--- (1, 4, 2, 3, 5)

zUB= 187
potato per ottimalit

Lista dei problemi candidati: {(4, 1, - - -)}

 Valutazione di (4, 1, -, -, -): fixing

1 2 3 Solo il job 1 schedulabile:

lunico figlio (4 1 - - -)

Valutazione di (4, 1, 2, -, -)
3 5
(3) = max(1/1)= 1 (5) =3/4

4 1 2 3 5
3 8 15 16 20

Soluzione del rilassamento chain: ammissibile L= 174

 ----- zUB= 187 zUB= 174

4---- L= 165

1----
41---

12--- 14---

zUB= 174 412--

potato per ottimalit potato per ottimalit

142--
L=: STOP
potato per ottimalit
 scelta del sottoproblema: FIFO (visita in ampiezza)
-----
# problemi valutati = 8

L= 183 1---- 4---- L= 165

12--- 14---
41---

123-- 124--
142-- 412--

12435 ottima
12345 41235 41253
12453 14253 14253 z*= 174
 scelta del sottoproblema: least lower bound
-----
# problemi valutati = 5 (!)

L= 183 1---- 4---- L= 165

12--- 14---
41---

123-- 124--
142-- 412--

12435 ottima
12345 41235 41253
12453 14253 14253 z*= 174
 Gerarchia di rilassamenti

Schedule ammissibili z
(risp. alle precedenze)

z*

LB2
schedule non ammissibili

rimozione archi
LB1

LB1 = eliminati i vincoli di precedenza O(n log n)

LB2 = eliminato solo larco (2,5) O(n2)
 Relazioni fra funzioni obiettivo

Definizione. Due funzioni obiettivo si dicono equivalenti se

uno schedule ottimo per la prima lo anche per la seconda
e viceversa.

Esempio. 1//Cj. e 1//Lj. sono equivalenti

Infatti, Lj = Cj dj

quindi Lj = Cj dj

ma lultimo termine costante e non dipende dallo schedule

 Lmax vs. Tmax
Uno schedule che minimizza Lmax minimizza anche Tmax
infatti,
Tmax = max {max(0,L1), ,max(0,Ln)} = max{0,
L1,,Ln} = max {0,Lmax}.

non vale il veceversa: job 1 2

pj 1 5
dj 7 6

-1
-1 0 -1
1 2 Tmax=Lmax=0 2 1 Lmax=-1
1 6 5 6
 Osservazione
Sia P un generico problema e RP un suo rilassamento.
se P ed RP hanno la stessa funzione obiettivo, allora
qualunque soluzione ottima di RP che sia anche
ammissibile per P ottima per P;
al contrario, se P ed RP hanno funzioni obiettivo diverse
questo non vero: consideriamo la seguente istanza di
1//wjCj ed il suo rilassamento 1//Cj.

1 30 20 3
job 1 2
1 2 2 1
pj 1 2
1 3 2 3
wj 1 10
C1+C2=4* C1+C2=5
w1C1+w2C2=31 w1C1+w2C2=23*
Numero di tardy job
1//Uj
 Struttura delle soluzioni ottime
ogni schedule ottimo composto da un insieme di job
che arrivano in tempo e da un secondo insieme di job in
ritardo (rispetto alle proprie due date)

il primo insieme rispetta EDD, in modo che Lmax sia

minimizzata (e minore o uguale a zero).

lordine dei job del secondo insieme non ha impatto

sulla funzione obiettivo

job in tempo (EDD) job in ritardo (qualsiasi ordine)

 Algoritmo di Moore
Costruisce lo schedule in avanti
J job gi schedulati (schedule parziale, secondo EDD)
Jd job gi esaminati e fissati come tardy job
Jc job ancora non esaminati

Inizializzazione:
J = , Jd = , Jc = {1, , n}.
Repeat:
1. Sia j* il job in Jc con la minima due date:
J:=J {j*}; Jc:=Jc \{j*}

2. Se j* in ritardo, cio p j > d j *

j J

sia k* il job in J pi lungo:

J:=J \{k*} Jd:=Jd {k*}
Until (Jc )
 Correttezza
Teorema. Lalgoritmo di Moore restituisce una soluzione
ottima di 1//Uj

Dimostrazione. Senza perdita di generalit si pu assumere

d1 d2 dn
Sia Jk un sottoinsieme di {1,,k} che soddisfa le seguenti
propriet:

1.ha il massimo numero Nk di job in tempo

2.fra tutti i sottoinsiemi di {1,, k} con Nk job in tempo, Jk ha il
minimo tempo totale di processamento

Per definizione, Jn corrisponde ad uno schedule ottimo.

Dimostriamo per induzione che lalgoritmo di Moore
restituisce Jn
 Induzione

lalgoritmo costruisce J1 in modo da rispettare (1) e (2).

Assumiamo che (1) e (2) valgano per k, cio che Moore
costruisca Jk e mostriamo che esse valgono per k+1

Due casi:

Caso a. Il job k+1 aggiunto allinsieme Jk ed completato in

tempo. Ovviamente, impossibile avere un maggior numero
di job in tempo fra quelli in {1,,k+1}, quindi vale (1).

Inoltre, il job k+1 deve appartenere allinsieme. Quindi, il

tempo di processamento totale minimo fra tutti gli insiemi
che soddisfano (1). Quindi vale (2).
 Induzione

Caso b. Il job k+1 aggiunto allinsieme Jk ed

completato in ritardo. Dato che Jk soddisfa (1) e (2)
deve essere Nk = Nk+1.

Quindi, aggiungere il job k+1 a Jk non aumenta il

numero di job in tempo. Ma aggiungere k+1 e
cancellare il job pi lungo fra quelli di Jk {k+1}
mantiene uguale il numero di job in tempo e riduce il
tempo di processamento complessivo. Questo completa
la prova.
 Esempio
job 1 2 3 4 5
pj 7 8 4 6 6
dj 9 17 18 19 21

iter 1. 1
0 7
iter 2. 1 2
0 7 15
iter 3. 1 2 3
0 7 15 19
1 3
0 7 11
 Esempio
job 1 2 3 4 5 iter 4.
pj 7 8 4 6 6
1 3 4
dj 9 17 18 19 21
0 7 11 17

iter 5. 1 3 4 5
0 7 11 17 23

3 4 5
0 4 10 16

Soluzione 3 4 5 1 2
1.4 Problemi min-sum con due date
(Tardiness totale Tj)
 Problema dello zaino binario

Zaino di capacit C +
Insieme N = {1,,n} di oggetti. Per ogni oggetto:
ingombro aj + profitto pj +
Problema: scegliere un insieme di oggetti di profitto
massimo tale che lingombro totale non ecceda la capacit.

Sia S una soluzione ottima e S una soluzione ottenuta da S

eliminando lelemento i.
S sol. ottima per il problema N = N \{i} e C=Cai
Altrimenti, detta S una sol ottima, S*= S {i} sarebbe
ammissibile e migliore di S, contraddizione.
 Formula ricorsiva

P(i, ) = massimo profitto ottenibile con i primi i oggetti

ed uno zaino di capacit

consideriamo lelemento i e valutiamo le due possibilit:

i tenuto nello zaino: P(i, ) = P(i 1, ai) + pi
i scartato: P(i, ) = P(i 1, ),
Quindi:

P(i, ) = max(P(i 1, ai)+ pi , P(i 1, ))

il problema consiste nel determinare P(n, C)

 Divide et impera vs.PD

il metodo divide et impera procede per decomposizioni

successive (top-down) e combina successivamente le
soluzioni dei sottoproblemi per ottenere la soluzione del
problema originario.
possibile (anzi, frequente) che molti sottoproblemi siano
uguali, quindi si esegue molto lavoro inutile!

La programmazione dinamica risolve i sottoproblemi in

modo bottom-up, memorizzando le soluzioni in una tabella
e utilizzandole ogni volta che servono alla soluzione di un
problema pi grande
 Complessit spaziale
i1 i

P(i1,ai)
+ pi
P(i1, ) P(i, )

ogni valore P(i, ) calcolato solo con elementi della

colonna precedente
Quindi, per calcolare il valore ottimo, sufficiente
memorizzare la colonna precedente spazio O(C)
 Ricostruire la soluzione

i1 i

P(i1,ai)
+ pi
P(i1, ) P(i, )

Per ciascun valore calcolato serve un puntatore

allelemento della riga precedente da cui derivato
Quindi, necessario mantenere lintera tabella
spazio O(nC)
 Programmazione dinamica nello
scheduling
Motivazione: Il branch-and-bound valuta diversi
sottoproblemi in cui lo schedule parziale contiene gli
stessi job (!)

- - - -

j1- - - j2 - - -

j1 j2 - - j2 j1 - -
 Ereditariet della struttura ottima
Consideriamo un problema del tipo:

1//j=1,,n hj(Cj)

In cui hj(Cj) una arbitraria funzione non decrescente di Cj

Ereditariet: in uno schedule ottimo i primi K job (per un

qualunque K{1,,n}) formano uno schedule ottimo per
il sottoproblema composto esclusivamente da tali job.

j1 j2 jK jn
 Ereditariet della struttura ottima

S j1 j2 jK jn

per un qualunque K {1, , n} il valore della funzione

obiettivo ha la seguente forma:
n K n

h
k =1
jk (C jk ) = h
k =1
jk (C jk ) + h
k = K +1
jk (C jk ) = A + B

Consideriamo il problema composto dai job {j1,,jK}: la

sequenza (j1,,jK) ottima. Altrimenti, potremmo ridurre A
senza modificare B, contraddicendo lottimalit di S.
 Metodo di Held e Karp

z(J) valore ottimo del problema in cui linsieme dei job J.

Se J = { j } allora z(J) = hj(pj)

Se |J | > 1, lultimo job completato al tempo pj ed i primi

|J| 1 job devono essere schedulati in modo ottimo nel
sottoproblema associato.
Quindi:

z (J ) = min z (J \ { j }),h j pk
j J
k J
 Metodo di Held e Karp

Per risolvere la formula ricorsiva

z (J ) = min z (J \ { j }),h j pk
j J
k J

Lalgoritmo procede in modo bottom-up iniziando a

calcolare le soluzioni ottime dei problemi con un solo
job, quindi utilizzando queste per risolvere i problemi
con due job, e via di seguito.
 Esempio: 1//Tj
job 1 2 3 4
pj 8 6 10 7
dj 14 9 16 16

Soluzioni per i quattro insiemi di un singolo

elemento:
z({ j }) = Tj = max (0, pj dj)

J {1} {2} {3} {4}

pjdj 6 3 6 9
z(J) 0 0 0 0
 Esempio: insiemi di due elementi
Soluzioni per i sei insiemi di due elementi:

z({j1,j2}) =
= min(z({j1})+(pj1+pj2) dj2, z({j2})+(pj1+pj2) dj1)

J {1,2} {1,3} {1,4} {2,3} {2,4} {3,4}

C(J) 14 18 15 16 13 17

last 1 2 1 3 1 4 2 3 2 4 3 4
Tj(C(J)) 0 5 4 2 1 0 7 0 4 0 1 1
z({J\{j}})
+Tj(C(J)) 0 5 4 2 1 0 7 0 4 0 1 1
min * * * * * *
z(J) 0 2 0 0 0 1
 Esempio: insiemi di tre elementi
Soluzioni per i quattro insiemi di tre elementi. Esempio:
J={1, 2, 3}, C(J) = p1+p2+p3

z({j1,j2,j3})=min(z({j1,j2})+C(J)dj3,
z({j1,j3})+C(J)dj2,z({j2,j3})+C(J)dj1)

J {1,2,3} {1,2,4} {1,3,4} {2,3,4}

C(J) 24 21 25 23

Last 1 2 3 1 2 4 1 3 4 2 3 4
Tj(C(J)) 10 15 8 7 12 5 11 9 9 14 7 7
z({J\{j}}+Tj(C(J))) 10 17 8 7 12 5 12 9 11 15 7 7
min * * * *
z(J) 8 5 9 7
 Esempio: insieme di quattro elementi
J {1,2,3,4}
C(J) 31

Last 1 2 3 4
Tj(C(J)) 17 22 15 15
z({J\{j}}+Tj(C(j))) 24 31 20 23
Min *
z(J) 20

Ricostruzione della soluzione ottima:

{1,2,3,4} job 3 schedulato per ultimo;
{1,2,4} job 4 schedulato per ultimo;
{1,2} job 1 schedulato per ultimo;
(2,1,4,3) soluzione ottima
 Complessit

Tempo: numero di sottoproblemi valutati

n n n n
+ + +K+
1 2 3 n
O(2n)

Spazio: 2n * da memorizzare.
 DP vs. branch&bound
----

1- - -
3 ---
4 ---
12-- 14--
31--
34--

13-- 32--
1423 1432 41--
2--- 43--

42--
1324 1342
21-- 24--

23--

2134 2413
4312
2431
2143 2341 4321
ottima 2314
 Applicabilit I
Il principio di ereditariet della struttura ottima si basa sul fatto
che un risequenziamento dei job (j1,,jK) non cambia il
termine B.

S j1 j2 jK jn

n K n

h
k =1
jk (C jk ) = h
k =1
jk (C jk ) + h
k = K +1
jk (C jk ) = A + B

Mantenendo la stessa struttura della funzione obiettivo, questo

non vero se le release date sono non tutte nulle.
 Controesempio
job 1 2 3 4
pj 5 5 5 5
rj 0 1 9 15
dj 11 9 15 20

0 1 0 0
1 2 3 4
Tj = 1
T1+T2=1
0 5 10 15 20

0 0 1 1
Tj = 2
2 1 3 4
T1+T2=0
1 6 11 16 21
 Applicabilit II
Il metodo di Held e Karp si applica anche a problemi
min-max.
Ad esempio se consideriamo 1//Lmax la ricorsione
diventa:

z (J ) = min max z (J \ { j }), p j d j
j J
j J
 1//Tj
Tardiness totale

algoritmo pseudo-polinomiale
 Struttura della sequenza ottima

Lemma 1.10 Se pjpk e djdk, esiste una sequenza

ottima in cui j precede k.

Ipotesi: d1 dn , pk = max (p1 , , pn )

Quindi, esiste una sequenza ottima in cui i job {1, , k 1}

precedono, in un qualche ordine, il job k.

1,}
{1,2,,k {k}

i rimanenti job {k+1, , n} possono precedere o seguire k

 Analisi di sensibilit
Prendiamo un job k qualunque e poniamo:

dk = max(dk ,Ck' )

Dove Ck' il massimo tempo di completamento del job k in

una (qualsiasi) soluzione ottima.

Otteniamo 2 istanze, entrambe con n job e tempi di

processamento p1, , pn

I1] d1, ,dn

I2] d1, ,dk1, max(dk,Ck'), dk+1 ,,dn

 Analisi di sensibilit
I1] d1,,dn

I2] d1,,dk-1, max(dk,Ck'),dk+1 ,,dn

Lemma 1.11
Ogni sequenza ottima per I2 ottima per I1

Dimostrazione. Siano:

S' uno schedule ottimo di I1 in cui k completato al

tempo Ck'

S'' uno schedule ottimo di I2 e Ck il relativo tempo di

completamento di k.
 Dimostrazione I
Siano:
V'(S) la tardiness totale della sequenza S rispetto ad I1
V (S) la tardiness totale della sequenza S rispetto ad I2

Valutiamo le due sequenze S' e S'' rispetto a I1 e I2.

Per costruzione:

1. V' (S') = V (S') + Ak

2. V' (S ) = V (S ) + Bk

Dimostriamo il teorema facendo vedere che:

V (S') > V (S ) e
Ak > Bk
 Dimostrazione II: consideriamo S'
Se Ck' dk , allora I1 e I2 coincidono ed il lemma provato;
altrimenti: la due date di k in I2 proprio Ck', cio coincide col
suo tempo di completamento in S'.
Quindi:
1. V' (S' ) = V (S' ) + Ak

I1 I2

dk Ck '

dk
Ak = Ck'
 Dimostrazione III: consideriamo S''

2. V'(S ) = V (S ) + Bk

consideriamo la sequenza S, in cui il job k completato in Ck

Bk = Tk'Tk=max(0,Ckdk)max(0,CkCk')

2 casi:
Bk = max(0, Ck dk ) se Ck Ck'
Bk = CkdkCk +Ck'=Ck'dk se Ck > Ck'

quindi:
Bk = max(0, min(Ck, Ck) dk )
 Dimostrazione IV

1. V'(S') = V (S') + Ak
2. V'(S) = V (S) + Bk

S ] Ak = Ck' dk
S''] Bk = max(0, min(Ck, Ck ) dk )
quindi: Ak Bk

Essendo S ottima per I2, deve essere V(S' )V(S)

da cui:

V ' (S' ) V ' (S)

 Struttura della sequenza ottima

Lemma 1.10 Se pjpk e djdk, esiste una sequenza

ottima in cui j precede k.

Ipotesi: d1 dn , pk = max (p1 , , pn )

Quindi, esiste una sequenza ottima in cui i job {1, , k 1}

precedono, in un qualche ordine, il job k.

1,}
{1,2,,k {k}

i rimanenti job {k+1, , n} possono precedere o seguire k

 Posizione dei job {k+1, , n}
Lemma 1.12
Esiste un intero , 0 n k, tale che esiste una
sequenza ottima S in cui il job k preceduto da tutti i job j
con j k + e seguito da tutti i job j per cui j > k +

Ck' : massimo tempo di completamento del job k in una

soluzione ottima dellistanza I1

S : schedule ottimo di I2 tale da soddisfare Lemma 1.10

Ck : tempo di completamento del job k in S

Dal Lemma 1.11: S ottima anche per I1, quindi

Ck max(Ck',dk)
 Dimostrazione I
Affermazione 1. Si pu assumere che k non sia preceduto in
S'' da alcun job j con

dj max(Ck',dk) Ck"
Infatti, lo swap:

j k
Ck dj

k j
Ck dj

produrrebbe una sequenza ammissibile non peggiore di

quella di partenza
 Dimostrazione II

Affermazione 2.
il job k in I2 ha una due date pari a max(Ck',dk). Quindi,
per il Lemma 1.10, deve essere preceduto in S da tutti i
job j con

dj max(Ck',dk).

Quindi: scegliendo come il pi grande intero tale che

dk + max(Ck',dk)

Ed essendo S'' ottima per I1, la prova completa

 Programmazione Dinamica
Insieme di job {1, , l} che inizia allistante t.
Dal Lemma 2, esiste un , 0 l k, per cui uno schedule
ottimo dato dalla concatenazione di tre insiemi di job:

1. in qualche ordine 2 3. in qualche ordine

1,k+1,,k+ } {k} {k+ +1,k+ +2,,l}

{1,2,,k
t
Ck() = t + j k+ pj

tempo di completamento di k

Affinch lintera sequenza sia ottima devono essere ottime le

sottosequenze relative agli insiemi 1 e 3 ricorsione
 Programmazione Dinamica

Il Lemma 2, purtroppo non fornisce un metodo di calcolo di

(perch?), ma solo un certificato di esistenza.

Tuttavia, 0 l k, quindi, possiamo enumerare tutti i

possibili valori di e scegliere quello che produce la sol.
migliore

1. in qualche ordine 2 3. in qualche ordine

1,k+1,,k+ } {k} {k+ +1,k+ +2,,l}

{1,2,,k
t
Ck() = t + j k+ pj

tempo di completamento di k
 Struttura del sottoproblema

Definiamo

J(j, l, k) { j, j + 1, , l 1, l}

linsieme di job di durata minore o uguale a pk. Linsieme non

contiene il job k anche se j k l.

V(J (j, l, k), t) tardiness totale dellinsieme J(j, l, k) in una

soluzione ottima quando linsieme iniziato al tempo t

condizioni al contorno:
V(, t) = 0,
V({j}, t) = max (0, t + pj dj)
 Ricorsione

V (J (j, l, s), t) = min0 l k {V (J (j, k+, k), t) +

+ max (0, Ck() dk) + V(J (k++1, l, k) , Ck() ) }

in cui:
pk = max (pr| r J(j, l, s))

valore ottimo:

V({1, , n}, 0)
 Esempio
job 1' 2' 3 4 job 1 2 3 4
pj 8 6 10 7 pj 6 8 10 7
dj 14 9 16 16 dj 9 14 16 16

V({1, 2, 3, 4}, 0) = min (

= 0 V(J(1, 3, 3), 0) + max (0, 24 16) + V(J(4, 4, 3), 24),

= 1 V(J(1, 4, 3), 0) + max (0, 31 16) )

=0 1,2 3 4
24
14 31
21
=1 1,2,4 3
 Esempio
job 1 2 3 4
pj 6 8 10 7
dj 9 14 16 16

V({1, 2, 3, 4}, 0) = min (

= 0 V(J(1, 3, 3), 0) + max (0, 24 16) + V(J(4, 4, 3), 24),

= 1 V(J(1, 4, 3), 0) + max (0, 31 16) )

V(J(1, 3, 3), 0) = max (0, 6 9) + max (0, 14 14) = 0

V(J(4, 4, 3), 24)) = 24 + 7 16 = 15

V({1, 2, 3, 4}, 0) = min ((0 + 8 + 15), V(J(1, 4, 3), 0) + 15)

 Esempio
job 1 2 3 4
pj 6 8 10 7
dj 9 14 16 16

V(J(1, 4, 3), 0) = min(

= 0 V(J(1, 2, 2), 0) + max (0, 14 14) + V(J(3, 4, 2), 14),
=1 V(J(1, 3, 2), 0) + max (0, 14 14) + V(J(4, 4, 2), 14),
=2 V(J(1, 4, 2), 0) + max (0, 21 14))

= 0,1 1 2 4
6 14

=2 1,4 2
21
 Esempio
job 1 2 3 4
pj 6 8 10 7
dj 9 14 16 16

V(J(1, 4, 3), 0) = min(

= 0 V(J(1, 2, 2), 0) + max (0, 14 14) + V(J(3, 4, 2), 14),
=1 V(J(1, 3, 2), 0) + max (0, 14 14) + V(J(4, 4, 2), 14),
=2 V(J(1, 4, 2), 0) + max (0, 21 14))

J(1, 2, 2) = {1} V(J(1, 2, 2), 0) = max (0, 6 9) = 0

J(3, 4, 2) = {4} V(J(3, 4, 2), 14) = max (0, 21 16) = 5

J(1, 3, 2) = {1} V(J(1, 3, 2), 0) = max (0, 6 - 9) = 0

J(4, 4, 2) = {4} V(J(4, 4, 2), 14) = max (0, 21 16) = 5
J(1, 4, 2) = {1,4} V(J(1, 4, 2), 0) = max (0, 6 9)
+ max (0, 13 - 16)= 0
 Esempio

job 1' 2' 3 4 job 1 2 3 4

pj 8 6 10 7 pj 6 8 10 7
dj 14 9 16 16 dj 9 14 16 16

V(J(1, 4, 3), 0) = min(

* = 0, = 1 0 + 0 + 5,
= 2 0 + 7) = 5
 Esempio
job 1 2 3 4
pj 6 8 10 7
dj 9 14 16 16

V({1, 2, 3, 4}, 0) = min ((0 + 8 + 15), V(J(1, 4, 3), 0) + 15)

= 0 23,
* = 1 20) = 20 {1, 2, 4} 3

V(J(1, 4, 3), 0) = min(

* = 0, = 1 0 + 0 + 5, {1, 2} 4 3
= 2 0 + 7) = 5
1 2 4 3
 Complessit
Tempo:
O(n3) sottoinsiemi J(j, l, k) e pj possibili istanti t.
Quindi, il numero di equazioni ricorsive da risolvere
pari a O(n3 pj). Ciascuna di esse richiede un tempo
O(n).

Quindi, lalgoritmo richiede tempo O(n4 pj)

Tardiness totale pesata

1//wjTj
 1// wjTj

Teorema. Il problema 1// wjTj NP-hard in senso

forte.

Lemma. Se pj pk e dj dk, e wj wk allora esiste una

sequenza ottima in cui j precede k.

Rilassamento preemptivo: ciascun job j di durata pj

suddiviso in pj job di durata unitaria.

Variabili decisionali:
xjk=1 se una unit del job j eseguita nellintervallo
[k 1,k] e 0 altrimenti
 1/prmp/ wjTj

[0,1]

job j intervalli
xjk
[k1, k]

[Cmax1, Cmax]
C max
x jk = p j , j = 1,K,n
k =1
n
x jk = 1,k = 1,K,C max
j =1
1/prmp/ wjTj: formulazione PL0-1

n C max occorre determinare cjk tali da

max c jk x jk rappresentare la tardiness
j =1 k =1 totale (o un suo rilassamento)

C max

x
k =1
jk = pj, j = 1,K,n

x
j =1
jk = 1, k = 1,K,C max

x jk {0,1}, j = 1,..., n; k = 1,..., Cmax

problema dei trasporti

 Richiamo: Problema dei trasporti
s localit sorgente e t destinazioni. Ciascuna sorgente
i{1,...,s} dispone di di unit di prodotto ed ogni destinazione
j {1,...,t} ne richiede almeno rj unit.
Il costo unitario di trasporto da i a j cij.
Determinare una politica di trasporto di costo minimo.
s t
min c ij x ij
i =1 j =1
t
xij quantit
trasportata
x
j =1
ij = di i {1,K, s }
da i a j s

x
i =1
ij = rj j {1,K, t }

x ij 0, int ere
 Coefficienti cjk

Determinare cjk tali che, per ogni schedule non

preemptivo, risulti:

n C max
w jT j c jk x jk
j =1 k =1

Definiamo i coefficienti di costo in modo che:

l
c jk w j max(l d j , 0)
k =l p j +1

per j = 1,,n; l = 1,,Cmax

 Funzione obiettivo
Allora, per una qualunque soluzione non preemptiva
risulta, per ogni j:

Cmax Cj
c jk x jk = c jk w j max(C j d j , 0)
k =1 k =C j p j +1

Cjpj+1 dj Cj

0, per k d j
Possibile scelta: c jk =
w j , altrimenti