4. Programmazione Lineare Intera

Transcript

1 . Programmazione Lineare Intera

2 Programmazione Lineare Intera (ILP) A(m n), b(m), c(n) interi; ILP in forma standard: min c x Ax = b x x intero Forma canonica, forma generale, trasformazioni: come LP. Rimuovendo il vincolo di interezza LP (rilassamento continuo dell ILP), tale che z(lp ) z(ilp ) (Dim: si cerca il minimo in un insieme più grande. ); z(lp ) è un lower bound di z(ilp ). Algoritmo ingenuo per ILP: begin determina col simplesso la soluzione ottima x dell LP corrispondente all ILP; if LP impossibile then ILP impossibile else if LP illimitato then ILP illimitato (salvo casi particolari) else if x è intero then x = soluzione ottima di ILP else arrotonda ogni x j frazionario all intero più prossimo end.

3 Ingenuo in quanto: ) l arrotondamento può essere non ammissibile: x ) soluzione intera e continua possono essere molto lontane : x Esistono casi in cui la soluzione ottima dell LP individuata dal simplesso è sicuramente intera?

4 Unimodularità B(m m) intera è unimodulare (UM) se det(b) = ±. A(m n) intera è totalmente unimodulare (TUM) se sua sottomatrice quadrata non singolare è UM. A TUM vertici di {x : Ax = b, x } interi b intero. Dim: B = matrice corrispondente ad una base di A; soluzione base: x = B b = Ba det(b) b (B a = aggiunta di B: b a ij = ( ) i+j minore(b ji )) A è TUM = B è UM = x è intero. A TUM vertici di {x : Ax b, x } interi b intero. Dim: dimostriamo che se A è TUM, (A I) è TUM. C = sottomatrice quadrata non singolare di (A I): A C permutiamo le righe di C = C = B D I det( C) = det(b) = det(c) = ± det( C) = ±. Quindi: se A è TUM, ILP si può risolvere col simplesso ( condizioni sufficienti per verificare se A è TUM).

5 Algoritmi generali per ILP: cutting-plane branch-and-bound (branch-and-bound) + (cutting-plane) = branch-and-cut. Algoritmi cutting-plane Schema generale: (Si suppone che LP non sia illimitato o impossibile.) begin risolvi l LP corrispondente all ILP; sia x la soluzione ottima trovata; while x non è intero do begin aggiungi all ILP una condizione lineare (taglio) che elimini una parte della regione ammissibile contenente x, ma non elimini alcuna soluzione ammissibile intera; risolvi l LP corrispondente al nuovo ILP; sia x la soluzione ottima trovata end end. o taglio x x x o taglio

6 Tagli di Gomory (958) y R, parte intera di y = y = max q intero : q y Y = tableau finale dell LP; B = base ottima ( B; x β() = ( z)) i(i =,..., m): x β(i) + x A j B A j B = x β(i) + y ij x j = y i y ij x j x β(i) + A j B A j B y ij x j }{{} intera x intero A j B y ij x j y i y ij x j y i (α) (β) (α) (β) : A j B (y ij y ij )x j (y i y i ) f ij = y ij y ij (parte frazionaria di y ij ); f ij < : A j B f ij x j f i (taglio di Gomory corrispondente alla riga i) Moltiplicando per ed aggiungendo un variabile slack: A j B f ij x j + s = f i

7 Se si aggiunge al tableau finale di un LP il taglio A j B f ij x j + s = f i ) non si elimina alcun punto intero ammissibile; ) il nuovo tableau contiene una base che è: Dim: a) non ammissibile per il primale se y i non è intero, b) ammissibile per il duale. ) il taglio è stato ottenuto esclusivamente imponendo all LP le condizioni di interezza; ) a) s è una nuova variabile base che, aggiunta a B, forma una base in cui la soluzione include s = f i, inammissibile per il primale se y i non è intero; b) nella riga si aggiunge uno nella colonna di s la soluzione resta ammissibile per il duale. Quindi conviene proseguire con l algoritmo del simplesso duale. Si noti che ) se y i non è intero, la soluzione attuale resta fuori dalla nuova regione ammissibile. La riga prescelta per il taglio viene detta riga generatrice. 5

8 procedure GOMORY: begin end. rimuovi il vincolo di interezza da ILP LP ; call TWO PHASE per LP e sia Y il tableau finale; if infeasible = false and unbounded = false then begin end feasible := true; k := (contatore dei tagli); while y i frazionario and feasible = true do begin end scegli un i : y i è frazionario; k := k + ; aggiungi al tableau l equazione A j B f ij x j + s k = f i ; call DUAL SIMPLEX; if infeasible = true (duale LP illimitato) then feasible := false (ILP impossibile) Ad ogni iterazione si elimina una parte della regione ammissibile. Si può dimostrare che il metodo converge (se: a) si sceglie sempre la prima riga frazionaria; b) si sceglie il pivot del simplesso duale secondo uno specifico metodo lessicografico). 6

9 Es : min x + 6 x + +x = 6 x + x + +x = x, interi x, x interi x x x z x 6 x x x x z x 6 6 x x x z x 6 6 riga generatrice : 6 x x x + x per sostituzione : x taglio : x + x ottimo dell LP taglio x Scegliendo riga : x x + s = 7

10 x x x s z x 6 6 s x x x s z x x riga generatrice : (,, intere) taglio : x + s per sostituzione : x ottimo taglio x 8

11 Equazione del taglio: x s + s = x x x s s z x x s x x x s s z x x 5 x ottimo x Soluzione ottima intera: x = = ; z =. 9

12 Es : min x + 6x + 6x + +x = x x x = x, interi x, x interi Fase : x a x x x ξ 6 x a x a x x x ξ x Fase : x x x z 7 5 x x x x z x x Riga generatrice : taglio x ( x + s = )

13 x x x s z x x s x x x s z x 6 x duale illimitato x primale impossibile. taglio x Quando il rilassamento LP è illimitato normalmente ILP è illimitato, ma in casi particolari può essere impossibile. Es: x

14 Algoritmi branch-and-bound (P ) min z = c x Ax = b x, intero x = soluzione ottima di P ; x = soluzione ottima del rilassamento continuo di P. c x z (= c x ). Se x è intera = x = x ; altrimenti Branching x min( x ) x scelta una componente x j frazionaria, imponiamo due condizioni mutualmente esclusive ed esaustive: x j x j or x j x j + (P ) min z = c x (P ) min z = c x Ax = b Ax = b x, intero x, intero x j x j x j x j + = z = min(z, z ). Es: x = = x or x : x x x

15 c x z ; c z. Normalmente x e/o non sono interi = si continua a ramificare, cioè: Da ogni problema P i si creano due nuovi problemi P j, P k a meno che: x i sia intero, oppure il rilassamento continuo di P i sia impossibile. Es: da P : = (P ) P + (P ) P + x x (impossibile) da P : x = 9 (P 5 ) P + (P 6 ) P + x x x 5 x soluzione intera: x =, =. (impossibile)

16 Rappresentazione mediante albero decisionale binario (L i = lower bound di z i ): L = Terminologia: x x nodo ramo L = 5... L = x 5 6 z = (intera) L = 7 x radice, 5, 6 foglie padre di e, figli di progenitore di,, 5 e 6,, 5, 6 discendenti di e Continuando fino a quando nessun nodo può più ramificare: Soluzione di P = soluzione della foglia di costo minimo. Bounding Problema P k : L k = c x k z k tutti i nodi discendenti da P k produrranno soluzioni z i z k L k ; z = miglior soluzione intera trovata finora; se L k (= min q intero L k ) z nessun discendente di P k potrà migliorare z si uccide il nodo k. (il nodo 5 uccide il nodo )

17 Inserimento dei vincoli nel tableau x i = a frazionario (in base): ) x i a x i + s = a s z c j... x i a [y ij ] s a si sottrae la riga di x i s r... r = a a < ) x i a + x i + s = a = t s z c j... x i a [y ij ] s t si somma la riga di x i s r... r = a a }{{} < < In entrambi i casi si prosegue col simplesso duale. 5

18 Es : min x + x + x + 6 8x 8 x, interi min x + x + + s = x + s = 6 8x 8 s = x,, s, s, s interi x a x a x s s s ξ 9 9 s x a 6 x a 8 8 x a x a x s s s ξ s x a x

19 x a x a x s s s ξ s x x s s s z 5 5 s Soluzione ottima non intera: x 5 branching su x. ) x : x + s = x s s s s z 5 5 s x 5 s 5 Impossibile. 7

20 ) x : x + s = x s s s s z 5 5 s x 5 s 5 x s s s s z s x Soluzione ottima intera: s 5 x =, =, z =. x x 8 x x x z =

21 Algoritmo branch-and-bound per un problema di ottimizzazione combinatoria procedure BRANCH AND BOUND: begin Π := {P } (insieme dei problemi attivi); z := +, X := (miglior soluzione ammissibile corrente); while Π do begin scegli un problema P Π per il branching; Π := Π \ {P }; genera i figli P i di P ; calcola i corrispondenti lower bound L i ; for each figlio P i di P do if L i z then uccidi P i else if L i dà una soluzione ammissibile then begin z := L i ; X := soluzione di P i ; Π := Π \ {P k : L k z } end else Π := Π P i end end. Occorre decidere: come scegliere il problema per il branching; come generare i problemi figli (branching non necessariamente binario); come calcolare i bound. 9

22 Altri problemi di ottimizzazione combinatoria Programmazione Lineare Intera Mista (MILP): min c x Ax = b x j j N x j intero j N Programmazione Lineare (LP): min c x Ax = b x j {, } j Problema Knapsack (KP): min c x a x = b x j {, } j Formulazione più frequente di KP: n elementi: p j = profitto, w j = peso dell elemento j; un contenitore (knapsack = zaino) di capacità c; scegliere gli elementi da inserire nel contenitore in modo da massimizzare il profitto complessivo: max n j= n j= p j x j w j x j x j c Assumiamo: p j, w j, c interi positivi. {, } j =,..., n

23 Algoritmo branch-and-bound per KP È conveniente ordinare gli elementi secondo valori non crescenti del profitto per unità di peso: p j p j+ j w j w j+ Albero decisionale binario: = x = = = x = = Strategia di esplorazione: al primo livello x =, x = ; se nodo attivo generato da (x j = ) si ramifica da questo, altrimenti dall ultimo nodo attivo generato da (x j = ). L insieme dei nodi attivi contiene sempre al più un nodo generato da (x j = ) uno o più nodi generati da (x j = )

24 Upper bound rilassamento continuo: x j {, } (j =,..., n) sostituito da x j (j =,..., n). Soluzione del rilassamento continuo (Dantzig, 957): si inseriscono con continuità gli elementi migliori frazionando il primo che non entra interamente, cioè: s := min{i : c := c s U := j= s j= i j= w j ; p j + c p s Es: n = 5 w j > c} (elemento critico); w s p = (,, 7, 6, ) w = (, 5,,, ) c = U = = 6 Si osservi che Upper bound di un nodo generato da (x j = ) upper bound del nodo padre.

25 Es: n = 5 p = (,, 7, 6, ) w = (, 5,,, ) c = Upper bound U sottolineato se occorre calcolarlo: U = 6 U = 6 U = 5 = U = 6 U = 5 x = U = 5 = U= 6 6 U= 5 x = x = x = x = x = x = x = 8 x 5 = x 5 = 7 U= 5 z = 9 z = 5

26 Questo tipo di strategia è detto depth first (esplorazione che tende a scendere in profondità il più possibile). minima occupazione di memoria e semplicità di implementazione poichè non occorre memorizzare l albero: vettore corrente: x = (,,,,,,,,, ) puntatore al livello corrente k x,... x k hanno i valori attualmente fissati nell albero. Passo principale: k := k + ; if w k c k else begin end j= x k := ; w j x j then x k := forward step U := upper bound per il nodo attuale; while U z (= miglior soluzione trovata) do begin end k := max{j < k : x j = }; x k := ; backtracking U := upper bound per il nodo attuale

27 Ricerca di un buon upper bound Un metodo per calcolare un upper bound è tanto migliore quanto più basso è il risultato (più alto, per lower bound). Miglioramento del bound di Dantzig (Martello Toth, 977): nella soluzione ottima l elemento s può essere se x s =, il bound è B = se x s =, il bound è B = s j= s j= w s+ p j + c p s+ p j (w s c) p s capacità da recuperare = nuovo bound U = max(b, B ) } {{ } Es. n = 5, p = ( 5, 8, 8, 7, 5), w = ( 5,,,, 5), c = U = 7; B = 6, B = 5 U = 6. incluso escluso w s } {{ } U U, cioè U è più stretto ( tight ) di U: ovviamente B U si può dimostrare per via algebrica che B U. U richiede poche operazioni in più = conveniente. peggior rapporto minima perdita In generale, compromesso tra qualità e tempo di calcolo. 5

28 Algoritmi branch-and-cut branch-and-cut := (branch-and-bound) + (cutting-plane). Algoritmo branch-and-bound in cui ad ogni nodo dell albero decisionale si generano tagli, cercando di trovare una soluzione intera, o almeno ottenere un bound migliore. Non si usano normalmente i tagli di Gomory in quanto essi dipendono dalle condizioni imposte dai nodi progenitori = occorrerebbe memorizzare i tagli relativi a ciascun nodo. Si usano tagli validi su tutto l albero decisionale, memorizzati in una struttura dati apposita (pool dei vincoli). Ad ogni nodo dell albero decisionale: x := soluzione del rilassamento LP del problema corrente; while x non è intera do if il pool contiene tagli violati da x then begin scegli uno o più tagli non ancora utilizzati; aggiungi i tagli al problema corrente; x := soluzione del rilassamento LP end else genera nuovi tagli e aggiungili al pool; (procedimento arrestato se raggiunto un limite di iterazioni) Principale difficoltà: metodo per la generazione dei tagli. 6

29 Pacchetto applicativo LINDO Linear, INteractive, and Discrete Optimizer. Accesso: $ RUN [DEISOR]LINDO : Comandi principali: COMMAND (dà l elenco dei comandi); HELP c (dà informazioni sul comando c); MAX oppure MIN (inizio dell inserimento di un problema); ST (inizio dell inserimento dei vincoli); END (termine dell inserimento di un problema); GO (risolve il problema corrente); QUIT (esce dall ambiente); Es: : MAX X + Y? ST? X + 5Y < 9? 7X + 6Y <? END : GO problema non necessariamente in forma standard; < sta per, > per ; le variabili sono per default non negative e illimitate; altri comandi per: definire variabili libere, intere o /; imporre upper e lower bound alle variabili; scrivere o leggere i problemi da file,... 7