Parte : Gestione dei progetti, Shop scheduling
Rappresentazione reticolare di un progetto Insieme di attività {,...,n} p i durata (nota e deterministica dell attività i) relazione di precedenza fra attività: Grafo G = (V, A) diretto (Activity on Node) aciclico aggiungiamo due nodi fittizi s e t a rappresentare l inizio e la fine del progetto; inseriamo gli archi: (s, j) per ogni nodo j che non ha archi entranti (i, t) per ogni nodo i che non ha archi uscenti associamo una lunghezza l ij = p i a ciascun arco (i, j) A
Durata del progetto attività durata pred. a - b - c a,b d a e d f c,e s a d b c f t e Rappresentiamo un schedule con un vettore [y,..., y n ] (istanti di inizio delle attività) La durata del progetto è quindi pari a y t y s
Minimizzare la durata del progetto (makespan) Formulazione PL: min y j yt y s y l ( i, j) A vincoli di precedenza i ij y i i V una sol. con qualche y i < può essere scalata, rimanendo ammissibile e di pari valore
Problema duale max l ij x ( i, j) A ij x ji - + (j,i) δ ( i) x ij (i,j) δ ( i) = i V \ { s, t} x sj = + ( s, j) δ ( s) x jt ( j, t) δ ( t) x ij = ( i, j) A problema del cammino di lunghezza massima da s a t in G
Algoritmo per il teorema della dualità forte il makespan equivale alla lunghezza del cammino massimo in G ponendo l uv := l uv equivale a calcolare un cammino da s a t di lunghezza minima G = (V, E) è aciclico, quindi il cambio di segno non introduce cicli di lunghezza negativa l albero dei cammini minimi in un grafo diretto aciclico si calcola in tempo O(m) Un vettore e(.) di interi definisce un ordinamento topologico dei nodi di G se risulta e(i) < e(j) per ogni arco (i,j) A
Ordinamento topologico j:= repeat j := j + Sceglie un nodo v con grado entrante pari a zero Assegna a v l etichetta e(v) := j Elimina v e i suoi archi uscenti until (esiste qualche nodo con grado entrante nullo) Se la rete rimanente contiene nodi ed archi allora G contiene un ciclo diretto Altrimenti le etichette definiscono un ordinamento topologico
Esempio s a d e b c f t v e(v) s a b 5 c 6 d e f t L algoritmo ha complessità O(m) [mantenendo il grado dei nodi e la lista dei nodi a grado entrante nullo]
Albero dei cammini minimi dato un ordinamento topologico (etichette e(.)) d(.) vettore delle distanze p(.) vettore dei predecessori Init. loop: d(s) =, d(v) =, p v = NULL, v V. for (j = to V ){ u: e(u) = j SCAN(u): forall v tale che (u,v) A if (d(v)>d(u)+l uv ) d v := d u + l uv ; p v := u; }
Esempio s a d e b c f t 5 5 d p s - a s b s c a d a e d f 5 e t 5 f
Earliest start time ponendo y v = d v, v V, si ha che y v rappresenta il minimo istante di inizio per l attività v tale da rispettare i vincoli di precedenza. Questo è detto Earliest Start Time, EST(v) EST(t) equivale quindi al minimo makespan a d e s b c 5 5 f t
Cammino critico Ogni cammino di lunghezza massima da s a t è detto cammino critico le attività apparenenti ad un cammino critico sono dette attività critiche: un ritardo in una di esse provoca un ritardo dell intero progetto a d e s b c 5 5 f t
Diagramma di Gantt a d e s b c f t 5 5 b d a c e f 5 5
Latest start time Tipicamente, il progetto deve essere terminato entro una data di consegna T ciò vincola ogni attività v ad essere iniziata entro un certo istante, detto Latest Start Time, LST(v) Se indichiamo δ(v) con la lunghezza del cammino massimo da v a t, si ha che LST(v) = T δ(v) s a d e δ(c) = b c f t
Total float La quantità LST(v) EST(v) è detta total float TF(v) s a d e δ(c) = b c f t T = 9 EST(c) = LST(c) = 6 TF(c) =
Trade-off tempi-costi In molti casi, una maggiore allocazione di risorse su una certa attività permette di ridurne la durata. costo pendenza d i b i durata minima a i durata nominale
Formulazione variabili decisionali: y i istante di inizio dell attività i, β i riduzione del tempo di processamento dell attività i Problema: determinare uno schedule tale che l intero progetto abbia durata non superiore a λ min y t y diβi i N s λ y j y a β ( i, j) i i i A β i a i b i i V
Formulazione min i N d y d β i i i N i i sostituzione di variabili: β i =y i β i y t y y y i j s β a ( i, j) i λ β i i i N A y i β i a i b i i N y i, β i non vincolate ogni riga ha al più un + ed un, quindi è il duale di un problema di flusso a costo minimo
Job Shop Scheduling insiemi J = {,...,n} di job, M={,...,m} di macchine Ogni job richiede una fissata sequenza di operazioni, ciascuna eseguita su una specifica macchina (con capacità unitaria e buffer di ingresso); cioè, visita le macchine secondo un dato instradamento Un job visita una macchina al più una volta (no-ricircolo) Problema: decidere la sequenza di processamento delle operazioni su ciascuna macchina in modo da minimizzare il makespan
Notazione (i, j), i M, j J operazione p ij durata dell operazione (i, j) N insieme di tutte le operazioni (se ogni job visita tutte le macchine esattamente una volta N = nm) m j numero di macchine visitate dal job j (i(j,),...,i(j,m j )) instradamento di j (sequenza delle macchine che visita) J(i) insieme dei job che visitano la macchina i
Esempio job i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] A [] [] [] B [] [] [] Una soluzione: A precede B sulla macchina A precede B sulla macchina A B B A A A B 5 B se B precedesse A sulla macchina?
Caso particolare: Flow Shop Tutti i job hanno la stessa sequenza (,,, m) di visita delle macchine J m- m Il buffer di ingresso consente i sorpassi: la sequenza di processamento della macchina i + può essere diversa da quella sulla macchina i. Il numero di soluzioni è pari a (n!) m Nel caso senza buffer (no-wait) ci sono n! soluzioni
Formulazione disgiuntiva A insieme delle coppie (i(j,h), j),(i(j,h+), j), h =,,m j, j=,,n t ij R n istante di inizio dell operazione ij minc max C max t + p ( i, j) ij ij N t rj t p ( i, j),( r, j) ij ij A t ij t ik p ik or t ik t ij p ij ( i, j),( i, k) N t ij ( i, j) N
i y jk = Formulazione PLM Se il job j precede k sulla macchina i altrimenti minc max C t t rj t ij t ij max ik t p ( i, j),( r, j) t t + p ( i, j),( r, j) ij t ik ij ij ij ij + M( y + My i jk ( i, j) N i jk p ) ik p i ij A i N M,( i, M,( i, j),( i, k) j),( i, k) N N
Esempio job i() [p i(),j ] i() [p i(),j ] i() [p i(),j ] i() [p i(),j ] [] [] [] [] [] [5] [6] [] [] []
Grafo disgiuntivo G = (N {s,z},a, D) grafo diretto s (sorgente) e z (pozzo) A archi congiuntivi rappresentano la relazione di precedenza fra le operazioni di ciascun job j (i(j,h), j) (i(j,h+), j), h =,,m j in aggiunta, per ogni j J, gli archi s (i(j, ), j) (i(j, m j ), j) z dalla sorgente alle prime operazioni dalle ultime operazioni al pozzo
Esempio (archi congiuntivi) job i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] [] [] [] [] [] [5] [6] [] [] [],,, s,,,, z,,,
Archi disgiuntivi G = ( N { s, z}, A, D) Rappresentano la sequenza dei job su ciascuna macchina per ogni coppia di operazioni da eseguirsi sulla macchina i, l arco (i,j) (i,k) indica che l operazione (i,j) precede (i,k) Per ogni macchina i M, e ciascuna coppia j,k di job in J(i), D contiene una coppia (disgiuntiva) di archi ( i, j) ( i, k) ( i, k) ( i, j) D(i) = {archi disgiuntivi associati alla macchina i}, inducono una clique in G
Esempio (archi disgiuntivi) job i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] [] [] [] [] [] [5] [6] [] [] [],,, s,,,, z,,,
Lunghezza degli archi job i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] [] [] [] [] [] [5] [6] [] [] [],,, 5 6 s,, 5,, z 6 5,,, Ad ogni arco (i,j) (h,k) si associa una lunghezza pari a p ij
Selezione Definizione. Un insieme S i D i che contiene esattamente un elemento per ciascuna coppia disgiuntiva è detto selezione della macchina i. S i è aciclica se (il grafo parziale) non contiene cicli orientati. Una selezione aciclica S i corrisponde (biunivocamente) ad un sequenziamento delle operazioni sulla macchina i.,,, S s,,,, z,,,
Schedule ammissibili Definizione. L unione degli archi congiuntivi e delle selezioni S i, i M, è detta selezione completa. Gli schedule ammissibili corrispondono biunivocamente alle selezioni complete acicliche,,, s,,,, z schedule non ammissibile,,,
Selezioni complete e schedule ammissibili,,, s 5,,,, 6 z lunghezza del cammino critico,,, = makespan 5 9 6 9
Riformulazione Job shop scheduling: trovare una selezione completa aciclica che minimizzi la lunghezza del cammino critico Oss. Valutare una soluzione (selezione completa) richiede la Oss. Valutare una soluzione (selezione completa) richiede la soluzione di un problema di ottimizzazione (calcolo del cammino critico)
Cicli Una selezione completa può formare cicli anche se le selezioni S i sono tutte acicliche,,, s,,,, z,,, Quindi, non è immediato progettare algoritmi che decompongono il problema per macchine
Lower bound I Supponiamo di aver scelto una selezione aciclica S i, per i M M. Poniamo S(M ) = i M S i Definiamo G(M ) il grafo parziale formato dagli archi congiuntivi e dagli archi in S(M ) Supponiamo che G(M ) sia aciclico e sia C max (M ) la lunghezza del cammino critico in G(M ) Proprietà. C max (M ) è un lower bound di C max quando le operazioni su ciascuna macchina i M sono sequenziate secondo S i Infatti, ciò equivale a considerare a capacità infinita le macchine in M\M
Esempio M = {},,, s,,, 5 6, z S,,, C max (M ) = lower bound per C max nel caso in cui la macchina processa le operazioni secondo S
Lower bound II Supponiamo di aver scelto una selezione aciclica S i, per i M M. Poniamo S = i M S i Teniamo adesso conto dell effetto di sequenziare un ulteriore macchina Per ogni operazione (i,j), i M, poniamo r ij =EST M (i,j) primo istante ammissibile per l operazione (i,j) fissate S i, i M d ij = LST M (i,j) + p ij due date per l operazione (i,j) affinché C max C max (M )
M = {} C max (M ) = Esempio,,, s,,, 5 6, z S,,, operazione (,) (,) (,) (,) (,) (,) (,) p ij 5 6 r ij 9 5 6 d ij 9 9
/r j /L max le operazioni (k,j), j J(k) associate ad una macchina k, con release date r (k,j) e due date d (k,j), identificano un istanza del problema/r j /L max Definiamo L max (k) il suo valore ottimo Esempio. k = Op. (,) (,) (,) p ij 5 r ij 9 d ij 9 (,) 5 (,) L max (k) = (,)
Lower bound II Proprietà. C max (M ) + L max (k) è un lower bound di C max quando le operazioni su ciascuna macchina i M sono sequenziate secondo S i Infatti, la selezione S k è scelta in modo da minimizzare il ritardo sul makespan, mentre tutte le altre macchine (M\M \{k}) sono assunte a capacità infinita il miglior lower bound si ottiene calcolando L max (k), per k M e scegliendo il massimo fra questi valori: L max (k*) = max k M {L max (k)}
Lower Bound II indichiamo con S*(k) la selezione associata alla soluzione ottima Aggiungendo gli archi S*(k) al grafo la lunghezza LB del cammino critico aumenta di L max (k) L max (k=) =,,, s,,, 5 6, z S 5,,, C max (M ) = LB =
Euristica Shifting Bottleneck Costruisce una selezione completa aciclica construendo iterativamente selezioni parziali acicliche M insieme delle macchine già sequenziate inizializzazione M = Passo generico: Costruisce il grafo G(M ) e calcola C max (M ) sceglie la macchina critica (bottleneck) k* = argmax k M {L max (k)} fissa (definitivamente) la selezione S*(k*) M := M {k*}
Validità Teorema. Gli archi orientati associati alla soluzione ottima di un problema a macchina singola non creano cicli nel grafo G(M ). Conseguenza: la selezione completa ottenuta dalle selezioni acicliche generate nelle singole iterazioni è aciclica.
Esempio job m j () [p m(),j ] m j () [p m(),j ] m j () [p M(),j ] m j () [p M(),j ] [] [] [] [] [] [5] [6] [] [] [] init. M = G(M ) s,,,,,,, z 5 6,,,
Esempio Iter. Calcola C max, r ij, d ij C max (M ) = s,,, [, ] [, ] [5, ] 5 6,,,, z [, ] [, ] [, 6] [6, ],,, [, ] [, 9] [5, ]
Iter : problemi /r j /L max Job Job p j p j 5 r j r j d j d j 6 9 Job Job p j 6 p j r j 5 6 d j r j 5 d j
/r j /L max macchina Job p j r j d j PEDD restituisce la soluzione ammissibile:
/r j /L max macchina Job p j 5 r j d j 6 9 PEDD restituisce la soluzione non ammissibile: 5 6 Soluzione ottima: 5-6 L max = 6
/r j /L max macchina Job p j 6 r j 5 6 d j Soluzione ottima: 5 9 5
/r j /L max macchina Job p j r j 5 d j Soluzione ottima 5
iter. Iter. Calcola C max M = {} s,,,,,,, z,,, 5 6 C max (M ) =
iter. s Iter. Calcola r ij, d ij M = {} [, 6] [6, ],,, 5 C max (M ) =,,,, z [, ] [, ] [6, ],,, [, ] [5, ] 6
Iter : problemi /r j /L max Job p j 5 r j d j 6 Job p j 6 r j 6 6 d j Job p j r j 5 d j
/r j /L max macchina Job p j 5 r j d j 6 Soluzione ottima: 5
/r j /L max macchina Job p j 6 r j 6 6 d j Soluzione ottima: 6 6
/r j /L max macchina Job p j r j 5 d j Soluzione ottima: 5
iter. Iter. Calcola C max M = {,} s,,, 5 5,,,, z 6,,, C max (M ) =
Iter. Calcola r ij, d ij M = {,} C max (M ) = s iter. [6, ],,, 5,,,, z [, ] [, ],,, 6 [5, ]
Iter : problemi /r j /L max Job Job p j 6 r j 6 d j p j r j 5 d j 6 5
Iter. Iter. Calcola r ij, d ij M = {,,} s,,, 5 6 5 6,,,, z [, ],,, C max (M ) = [5, ]
STOP M = {,,, } La soluzione calcolata è: s,,, 5 6 5,,,, z,,, 6 C max (M ) =
Operazioni su schedule Due operazioni trasformano uno schedule ammissibile in un altro schedule ammissibile: shift: anticipa un operazione jump: anticipa un operazione in un intervallo in cui la macchina è ferma modificando la sequenza
Schedule attivi Definizione. Uno schedule ammissibile si dice attivo se nessuna operazione può essere anticipata mediante uno shift o un jump senza ritardare un altra operazione
Branch-and-bound Esiste uno schedule ottimo che è attivo, quindi restringiamo la ricerca agli schedule attivi ad ogni livello dell albero di enumerazione si fissa un operazione le operazioni fissate ad un dato sottoproblema formano uno schedule parziale un operazione si dice disponibile se tutte le operazioni che la precedono sono state schedulate. AO = insieme delle operazioni disponibili
Branching step (inizializzazione) calcola l insieme AO e r ij per ogni (i,j) AO step (selezione della macchina) calcola t(ao) = min (i,j) AO {r ij + p ij } = r i*j + p i*j step (branching) BO = {operazioni (i*,j) AO tali cher i*j <t(ao)} per ogni operazione in BO: genera un sottoproblema fissando tale operazione come successiva
Esempio job i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] i(j,) [p i(j,),j ] [] [] [] [] [] [5] [6] [] [] [] nodo radice:,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao) = min{+, +, +} =, i* = r, = BO = {(,)} branching: genera un singolo sottoproblema A fissando l operazione (,)
nodo A:,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao) = min{+, +, +} =, i* = r, =, r, =, r, = BO={(,), (,)} (,) A (,) (,) B C
nodo B:,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao)=min{+,+,+} =, i* = r, =, r, = BO = {(,),(,)} sottoproblemi D,E nodo C:,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao) =min{+, +, +} =, i* = r, =, r, = BO = {(,),(,)} sottoproblemi F,G
(,) A (,) (,) B (,) (,) C (,) (,) D E F G
nodo D,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao)=min{+, +, +} =, i* = r, =, r, = BO = {(,),(,)} sottoproblemi H,I nodo E,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao)=min{9+,+, +} = 5, i* = r, =, r, = BO = {(,),(,)} sottoproblemi J,K
(,) A (,) (,) B (,) (,) C (,) (,) D (,) (,) E (,) (,) F G H I J K
nodo F,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao) =min{9+, +, 9+} = 5, i* = r, =, r, =9 BO = {(,)} sottoproblema L nodo G,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao) =min{+, +5, +} = 5, i* = r, =, r, = BO = {(,),(,)} sottoproblemi M,N
(,) A (,) (,) B (,) (,) C (,) (,) D (,) (,) (,) (,) E (,) F G (,) (,) H I J K L M N
nodo H,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao)=min{+, 5+5, 5+} = 9, i* = r, =5 BO = {(,)} sottoproblema O nodo I,,, 5 5 6 s,,,, z 5,,, AO = {(,),(,),(,)} t(ao)=min{+, 9+, +5} = 9, i* = r, = BO = {(,)} sottoproblema P
(,) A (,) (,) B (,) (,) C (,) (,) D (,) (,) (,) (,) E (,) F G (,) (,) (,) H I J K L (,) M N O P
nodo J,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao)=min{9+,5+, 5+} = 9, i* = r, =5 BO = {(,)} sottoproblema R nodo K,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao)=min{9+,5+, 5+} =, i* = r, =5 BO = {(,)} sottoproblema S
(,) A (,) (,) B (,) (,) C (,) (,) D (,) (,) (,) (,) E (,) F G (,) (,) H I J K L (,) (,) (,) (,) M N O P R S
nodo L,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao) =min{9+, 9+, 5+} =, i* = r, =5 BO = {(,)} sottoproblema T
nodo M,,, 5 5 6 s,,,, z 5,,, AO = {(,),(,),(,)} t(ao) =min{+, 6+6, +} = 5, i* = r, = BO = {(,)} sottoproblema U nodo N,,, 5 6 s,,,, z,,, AO = {(,),(,),(,)} t(ao) =min{+, 5+5, 5+} =, i* = r, =5 BO = {(,)} sottoproblema V
(,) A (,) (,) B (,) (,) C (,) (,) D (,) (,) (,) (,) E (,) F G (,) (,) H I J K L (,) (,) (,) (,) (,) O P R S T (,) M U (,) N V
nodo O,,, 5 6 s,,,, z,,, AO = {(,),(,)} t(ao)=min{+, 5+5} =, i* = r, =5 BO = {(,)} sottoproblema W nodo P,,, 5 5 6 s,,,, z 5,,, AO = {(,),(,)} t(ao)=min{+, 9+} =, i* = r, = BO = {(,)} sottoproblema X
nodo R,,, 5 6 s,,,, z,,, AO = {(,),(,)} t(ao)=min{9+, 5+} =, i* = r, =9 BO = {(,)} sottoproblema Y nodo S,,, 5 6 s,,,, z,,, AO = {(,),(,)} t(ao)=min{9+,5+} = 9, i* = r, =5 BO = {(,)} sottoproblema Z
nodo T,,, 5 6 s,,,, z,,, AO = {(,),(,)} t(ao) =min{9+, 9+} =, i* = r, =9 BO = {(,)} sottoproblema α
nodo U,,, 5 5 6 s,,,, z 5,,, AO = {(,),(,)} t(ao) =min{+, 6+6} =, i* = r, =6 BO = {(,)} sottoproblema β nodo V,,, 5 6 s,,,, z,,, AO = {(,),(,)} t(ao) =min{+, 5+5} =, i* = r, =5 BO = {(,)} sottoproblema χ
(,) A (,) (,) B (,) (,) C (,) (,) D (,) (,) (,) (,) E (,) F G (,) (,) H I J K L (,) (,) (,) (,) (,) O P R S T (,) (,) (,) (,) (,) W X Y Z α (,) (,) M U β (,) (,) N V χ
Regole di dispatching FCFS (First Come First Served): ogni macchina esegue l operazione processabile secondo l ordine di arrivo MWR (Most Work Remaining): fra le operazioni processabili, ogni macchina processa quella con il maggior tempo di processamento residuo (di tutte le operazioni rimanenti del job) SPT (Shortest Processing Time): ogni macchina processa l operazione disponibile più breve
Esempio: FCFS job i() [p i(),j ] i() [p i(),j ] i() [p i(),j ] i() [p i(),j ] [] [] [] [] [] [5] [] [] [] [] t = :
Esempio: FCFS job m j () [p m(),j ] m j () [p m(),j ] m j () [p M(),j ] m j () [p M(),j ] [] [] [] [] [] [5] [] [] [] [] t = :
Esempio: FCFS job m j () [p m(),j ] m j () [p m(),j ] m j () [p M(),j ] m j () [p M(),j ] [] [] [] [] [] [5] [] [] [] [] t = : 5 9
Esempio: FCFS job m j () [p m(),j ] m j () [p m(),j ] m j () [p M(),j ] m j () [p M(),j ] [] [] [] [] [] [5] [] [] [] [] t = 5: 5 9
Esempio: FCFS job m j () [p m(),j ] m j () [p m(),j ] m j () [p M(),j ] m j () [p M(),j ] [] [] [] [] [] [5] [] [] [] [] t = 9: 5 9 6
Esempio: FCFS job m j () [p m(),j ] m j () [p m(),j ] m j () [p M(),j ] m j () [p M(),j ] [] [] [] [] [] [5] [] [] [] [] t = : 5 9 6
Esempio: FCFS job m j () [p m(),j ] m j () [p m(),j ] m j () [p M(),j ] m j () [p M(),j ] [] [] [] [] [] [5] [] [] [] [] t = 6: 5 9 6 9
Esempio: FCFS job m j () [p m(),j ] m j () [p m(),j ] m j () [p M(),j ] m j () [p M(),j ] [] [] [] [] [] [5] [] [] [] [] t = : 5 9 6 9 5
Selezione completa FCFS s,,, 5,,,, z,,, Cammino critico s-(,)-(,)-(,)-(,)-(,)-z di lunghezza 5
Ricerca Locale Teorema. Sia S una soluzione ammissibile (selezione completa aciclica) e (i, j) un arco disgiuntivo di un cammino critico del grafo G(S). Allora, sostituendo (i, j) con (j, i) si ottiene una nuova selezione completa aciclica (cioè una nuova soluzione ammissibile) Il vicinato di una soluzione S è definito come l insieme delle soluzioni ottenibili scambiando il verso di un arco disgiuntivo appartenente ad un cammino critico. Teorema. Per ogni soluzione S esiste una sequenza finita di mosse che genera una soluzione ottima
FCFS: soluzione di partenza s,,, 5,,,, z,,, Cammino critico s-(,)-(,)-(,)-(,)-(,)-z di lunghezza 5 Due possibili mosse: (,)-(,) oppure (,)-(,). La seconda produce una soluzione di costo (provare)
mossa : peggiorativa s,,, 5,,,, z,,, Scambio arco (,)-(,) di lunghezza con (,)-(,) di lunghezza Cammino critico s-(,)-(,)-(,)-(,)-(,)-(,)-z di lunghezza 9
mossa s,,, 5,,,, z,,, Scambio arco (,)-(,) di lunghezza con (,)-(,) di lunghezza Cammino critico s-(,)-(,)-(,)-(,)-(,)-z di lunghezza (!!)
Soluzione dopo mosse: migliora FCFS FCFS 5 9 6 9 5 Ricerca Locale 5 9