Algoritmi di tipo preflow-push - DMI

Capitolo 3Algoritmi preflow-pushIl problema fondamentale degli algoritmi augmenting path è costituito dall’onerosaoperazione di invio di flusso lungo un path, che richiede tempo O(n) nel caso peggiore. Glialgoritmi preflow-push consentono di ovviare a tale inconveniente evitando di spedireflusso lungo path, ottenendo un notevole miglioramento nella complessità. Al fine dicomprendere l’idea alla base degli algoritmi preflow-push, immaginiamo che la reteresidua rappresenti una rete interconnessa di serbatoi e tubi. In particolare i nodirappresentano serbatoi, gli archi della rete residua rappresentano condotti flessibili traserbatoi, e la distance label associata ad ogni nodo indica quanto il serbatoio è in altorelativamente al livello del terreno. In tale sistema vogliamo inviare acqua dal serbatoiosorgente al serbatoio pozzo. Immaginiamo, ancora, che il flusso lungo un arco ammissibilerappresenti acqua che scorre verso il basso. Inizialmente, muoviamo il serbatoio sorgenteverso l’alto in modo tale che l’acqua in esso contenuta scorra verso i serbatoi vicini. Ingenerale, l’acqua scorre verso il basso in direzione del pozzo. Può capitare, tuttavia, cheparte del liquido resti bloccata in un serbatoio che non ha serbatoi vicini posizionati più inbasso relativamente ad esso. Se è così, alziamo il serbatoio in modo che defluisca l’acquain esso accumulata. Prima o poi, non potremo più inviare flusso verso il pozzo.Continuiamo allora ad alzare i serbatoi, in modo tale che l’acqua in eccesso ritorni indietroverso il serbatoio sorgente. Terminiamo tale processo quando tutti i serbatoi diversi daquello sorgente e quello pozzo, non hanno liquido in eccesso.32

3.1 Generic preflow-push algorithmConsideriamo l’esempio mostrato in figura 3.1. Un qualsiasi algoritmo augmenting path,quando applicato a tale problema, individuerà 5 augmenting path, ognuno di lunghezza 6,ed aumenterà di una unità di flusso lungo ognuno di tali path. Osserviamo, tuttavia, chenonostante gli augmenting path condividano i primi 4 archi, ogni aumento attraverserà tuttii 6 archi.r ijs8 8 8 8tFig. 3.1. Svantaggio degli algoritmi augmenting path.Se avessimo inviato 5 unità di flusso dal nodo 1 al nodo 5, e dunque una unità di flussolungo ognuno dei differenti path di lunghezza 2, avremmo evitato le ripetitivecomputazioni per l’attraversamento degli archi comuni. L’operazione di aumento lungo unpath degli algoritmi augmenting path può essere decomposta nella elementare operazionedi invio di flusso lungo archi individuali. Dunque l’invio di δ unità di flusso lungo un pathdi k archi può essere considerato come k invii di δ unità di flusso lungo ognuno degli archidel path. Ci riferiremo ad ognuno di tali invii come operazione di push. Gli algoritmipreflow-push inviano flusso lungo archi individuali anziché lungo augmenting path. Acausa di questa caratteristica, tali algoritmi non soddisfano i vincoli di bilanciamento dimassa (1.1b) in fasi intermedie. Infatti tali algoritmi consentono al flusso entrante in unnodo di eccedere il flusso uscente dallo stesso nodo. Formalmente, definiamo preflow unafunzione x : A → R che soddisfa i vincoli di capacità (1.1c) e il seguente rilassamento deivincoli (1.1b):33

∑xji{ j:(j , i ) ∈ A}−∑xij{ j:(i,j ) ∈ A}≥0∀i∈ N\ { s,t}.Gli algoritmi preflow-push mantengono un preflow in ogni fase intermedia. Per un datopreflow x, definiamo l’eccesso in un nodo( i)=∑{ j:(j,i)∈A}−∑e xji xij.{ j:(i,j ) ∈A}i ∈ N comeIn un preflow, e( i)≥ 0 ∀i∈ N \ { s,t}. Tuttavia, poiché non esiste flusso uscente dal nodo t,anche e ( t)≥ 0 . Pertanto il nodo s è l’unico nodo con eccesso negativo. Ci riferiremo ad unnodo con eccesso strettamente positivo come nodo attivo; per convenzione, i nodi sorgentee pozzo non sono mai attivi.Gli algoritmi augmenting path durante l’esecuzione mantengono l’ammissibilità dellasoluzione, ovvero il soddisfacimento dei vincoli (1.1), e convergono verso l’ottimalità;invece gli algoritmi preflow-push cercano di raggiungere l’ammissibilità della soluzione.In un algoritmo preflow-push, la presenza di nodi attivi indica l’inammissibilità dellasoluzione corrente. Di conseguenza l’operazione di base degli algoritmi è selezionare unnodo attivo e tentare di spedire il flusso in eccesso verso nodi adiacenti. Poiché il finedell’algoritmo è inviare flusso al nodo pozzo, il flusso in eccesso in un nodo viene speditoad un nodo adiacente che sia più vicino al pozzo di quanto lo sia il nodo con eccessopositivo. Come negli algoritmi shortest augmenting path, misuriamo la vicinanza al nodopozzo basandoci sulle distance label; pertanto inviare flusso verso un nodo che sia vicino alpozzo equivale ad inviare flusso su archi ammissibili. Se il nodo attivo che stiamoconsiderando non ha archi ammissibili, incrementiamo la sua distance label al fine dicreare almeno un arco ammissibile. L’algoritmo termina quando la rete non contiene alcunnodo attivo. Descriviamo ora formalmente l’algoritmo preflow-push.algorithm preflow-pushbeginpreprocess;while esiste un nodo attivo dobeginseleziona un nodo attivo i;push/relabel(i);end;end;34

procedure preprocessbeginx := 0;calcola le distance label esatte d(i);x sj := u sj per ogni arco (s, j)∈A(s);d(s) := n;end;procedure push/relabel(i)beginif la rete contiene un arco ammissibile (i, j) theninvia δ := min{e(i), r ij } unità di flusso dal nodo i al nodo j;else d(i) = min{d(j) +1 : (i, j)∈A(i) e r ij > 0};end;L’operazione push spinge δ unità di flusso dal nodo i al nodo j, decresce di δ unità siae(i) sia r ij ed aumenta di δ unità e(j) e r ji . Un’ operazione push di δ unità su un arco (i, j) èsaturating se δ=r ij ed è non saturating altrimenti. Osserviamo che un push non saturatingdal nodo i riduce e(i) a zero. L’operazione relabel aumenta la distance label di un nodo, inmodo tale da creare un arco ammissibile su cui l’algoritmo possa eseguire altre operazionidi push. L’operazione preprocess svolge diverse funzioni. Innanzitutto invia flusso dallasorgente verso i nodi adiacenti, in modo tale da rendere attivi i nodi adiacenti alla sorgente.Successivamente, poiché l’operazione precedente satura tutti gli archi uscenti dal nodo s,rendendo gli archi inammissibili, pone d(s)=n, che non violerà la condizione di validità(2.2). Inoltre, essendo d(s)=n, la proprietà (4.3) implica che la rete residua non contienedirect path dal nodo s al nodo t. Essendo poi le distance label non decrescenti, è garantitoche nelle iterazioni successive la rete residua non conterrà mai un direct path dal nodosorgente al nodo pozzo, pertanto non sarà necessario inviare ulteriore flusso dal nodo s. Perillustrare l’algoritmo generic preflow-push, consideriamo l’esempio dato in figura 3.2(a);in figura 3.2(b) è possibile notare la rete residua dopo l’operazione di preprocess.Supponiamo che l’algoritmo selezioni il nodo 2 per l’operazione di push/relabel. L’arco (2,4) è il solo arco ammissibile e l’algoritmo esegue un’operazione di push (saturating) delvalore δ =min {e(2), r 24 }=min{2, 1}=1. La Figura 3.2(c) rappresenta la rete residua inquesta fase. Supponiamo che l’algoritmo selezioni ancora il nodo 2. Poiché non esistono35

figura 3.2(f). Ora la rete residua non contiene alcun nodo attivo e l’algoritmo termina. Ilvalore del flusso massimo nella rete è e(4)=6.Assumendo che l’algoritmo generic preflow-push termini, possiamo mostraresemplicemente che esso individua un massimo flusso. L’algoritmo termina quando glieccessi risiedono solo nel nodo sorgente o nel nodo pozzo, il che implica che al terminedell’algoritmo il preflow è un flusso. Poiché d(s) = n, la rete residua non contiene directpath dal nodo sorgente al nodo pozzo, il che, per il teorema 2.1, implica che il flusso èmassimo.Complessità dell’algoritmoPer analizzare la complessità iniziamo a stabilire un importante risultato: le distance labelsono sempre valide ed il numero di incrementi subiti dalle distance label è limitatosuperiormente. La prima di queste affermazioni segue dal lemma 2.7 poiché, comel’algoritmo shortest augmenting path, l’algoritmo preflow-push spinge flusso solo su archiammissibili e rietichetta un nodo solo quando non esistono archi ammissibili uscenti datale nodo. Dimostriamo ora la seconda affermazione.Lemma 3.1. Durante l’esecuzione dell’algoritmo preflow-push, ogni nodo i coneccesso positivo è connesso al nodo s da un direct path dal nodo i al nodo s nella reteresidua.Dim. Notiamo che per un preflow X, si ha: e(s) ≤ 0 ed e(i) ≥ 0 per ogni i ∈ N \{s}.Per il teorema della decomposizione del flusso (vedi appendice A.1), possiamodecomporre ogni preflow X, relativamente alla rete originale G, in flussi non negativilungo (1) path dal nodo s al nodo t, (2) path dal nodo s ai nodi attivi e (3) flussi su ciclidiretti. Sia X un preflow in G e sia i un qualsiasi nodo attivo. La decomposizione del flussodi X deve contenere un direct path P dal nodo s al nodo i, infatti i path dal nodo s al nodo te i flussi intorno ai cicli non contribuiscono all’eccesso del nodo i. La rete residua contieneil reverse di P, ovvero P in cui ogni arco è capovolto, e dunque un direct path dal nodo i alnodo s.37

Tale lemma implica che durante un’operazione di relabel, l’algoritmo non minimizza su uninsieme vuoto.Lemma 3.2. Per ogni nodo i∈ N, d(i) < 2n.Dim. L’ultima volta che l’algoritmo ha rietichettato il nodo i, il nodo aveva uneccesso positivo, così la rete residua conteneva un direct path P di lunghezza al più n-2 dalnodo i al nodo s. Il fatto che d(s) = n e che d(k) ≤ d(l)+1 per ogni arco (k, l) nel path Pimplica che d(i) ≤ d(s)+|P| < 2n.Poiché ogni volta che l’algoritmo rietichetta il nodo i, d(i) aumenta di almeno una unità,abbiamo stabilito il seguente risultato:Lemma 3.3. Ogni distance label incrementa al più 2n volte. Di conseguenza, ilnumero totale di operazioni di relabel è al più 2n 2 .Lemma 3.4. L’algoritmo esegue al più nm pushes saturating.Dim. Questo risultato deriva direttamente dai lemmi 3.2 e 2.9.In base alla proprietà 2.8, il lemma 3.2 implica che il tempo necessario per identificarearchi ammissibili ed eseguire operazioni di relabel è O(nm). Valutiamo ora il numero dipush non saturating eseguiti dall’algoritmo.Lemma 3.5. L’algoritmo generic preflow-push esegue O(n 2 m) push non saturating.Dim. Proviamo il lemma usando le funzioni potenziali. Denotiamo con I l’insiemedei nodi attivi. Consideriamo la funzione potenziale Φ =∑i∈ Id ( i). Poiché |I| < n e d(i)

di al più ε unità. Poiché, per il lemma 3.2, l’incremento totale di d(i) è limitato da 2n perogni nodo i, si ha che l’incremento totale della funzione Φ dovuto ad incrementi didistance label è limitato da 2n 2 .Secondo caso. L’algoritmo individua un arco ammissibile su cui può inviare flusso, dunqueesegue un push saturating o un push non saturating. Un push saturating sull’arco (i, j) puòcreare un nuovo eccesso al nodo j, incrementando il numero dei nodi attivi di uno eincrementando Φ di d(j). Essendo d(j) limitato da 2n ed il numero di push saturatinglimitato da nm, l’incremento totale dovuto ad operazioni di push saturating è limitato da2n 2 m. Notiamo ora che un push non saturating sull’arco (i, j) non incrementa |I|. Il pushnon saturating decrementerà Φ di d(i) poiché i diventerà non attivo. Se il nodo j diventeràattivo dopo il push, Φ incrementerà di d(j)=d(i)-1, dunque in totale Φ viene decrementatadi 1. Se il nodo j era già attivo prima del push, Φ decresce di un valore pari a d(i). Diconseguenza Φ decresce di almeno una unità in corrispondenza di ogni push nonsaturating. Riepilogando, il valore iniziale di Φ è limitato da 2n 2 e il massimo incrementoche può subire è 2n 2 +2n 2 m. Ogni push non saturating decrementa Φ di almeno una unità.Di conseguenza, il numero di push non saturating è limitato da 2n 2 +2n 2 +2n 2 m = O(n 2 m).Specifichiamo ora come l’algoritmo tiene traccia dei nodi attivi per le operazioni di push erelabel. L’algoritmo mantiene un insieme LIST di nodi attivi, aggiunge a LIST i nodi chediventano attivi dopo una operazione di push e che non sono in LIST e cancella da LIST inodi che diventano inattivi dopo un push non saturating. Diverse strutture dati (es. liste adoppio puntatore) possono essere utilizzate per la rappresentazione dell’insieme LIST inmodo tale che l’algoritmo possa aggiungere, cancellare o selezionare elementi in tempoO(1). Di conseguenza è facile implementare l’algoritmo preflow-push in modo tale che iltempo d’esecuzione sia O(n 2 m). Abbiamo così stabilito il seguente risultato:Teorema 3.6. L’algoritmo generic preflow-push impiega O(n 2 m) per determinareun flusso massimo.Implementazioni specifiche dell’algoritmo preflow-pushIl tempo d’esecuzione dell’algoritmo precedente è comparabile con quello dell’algoritmoshortest augmenting path. Tuttavia, specificando regole diverse per la selezione dei nodi39

attivi per le operazioni di push e relabel, otteniamo algoritmi diversi, ognuno dei quali concomplessità diversa da quella dell’algoritmo generico. Quello che è computazionalmenteoneroso nell’algoritmo generico preflow push è l’elevato numero di push non saturating,che può essere sostanzialmente ridotto attraverso specifiche regole per la selezione dei nodiattivi.3.2 FIFO preflow-push algorithmDefiniamo innanzitutto il concetto di esame di un nodo. In una generica iterazione,l’algoritmo generic preflow push, una volta selezionato il nodo i, esegue un push,saturating o non saturating, oppure un’operazione di relabel. Se l’algoritmo esegue un pushsaturating, il nodo selezionato potrebbe essere ancora attivo, ma non è detto che esso vengaselezionato nuovamente nella successiva iterazione. Assumiamo che ogniqualvoltal’algoritmo preflow push seleziona un nodo attivo, esso esegue operazioni di push da talenodo finché l’eccesso del nodo diventa nullo o il nodo viene rietichettato. Di conseguenza,l’algoritmo potrebbe eseguire diversi push saturating seguiti da un push non saturating oun’operazione di relabel.L’algoritmo preflow push FIFO, esamina i nodi nell’ordine First In First Out, mantenendol’insieme LIST come una coda. Esso seleziona un nodo i dalla testa di LIST, esamina talenodo, ed aggiunge i nodi divenuti attivi in coda a LIST. Se il nodo estratto diventa nonattivo, l’algoritmo estrae il nodo successivo in LIST. Se invece il nodo estratto vienerietichettato, l’algoritmo inserisce il nodo in coda a LIST. Illustriamo l’algoritmoconsiderando l’esempio in figura 3.3.(a)(b)Fig. 3.3. Funzionamento dell’algoritmo FIFO preflow push.L’operazione di preprocess crea un eccesso di 10 unità sui nodi 2 e 3, la coda dei nodiattivi è LIST={2, 3}. L’algoritmo estrae il nodo 2 dalla coda e lo esamina. Supponiamo40

che esso esegua un push saturating di 5 unità sull’arco (2, 4) e un push non saturating di 5unità sull’arco (2, 5), ottenendo la rete in figura 3.3 (b).(c)Fig. 3.3. Funzionamento dell’algoritmo FIFO preflow push.Dopo tali operazioni di push i nodi 4 e 5 diventano attivi e dunque saranno inseriti nellacoda, ottenendo LIST={3, 4, 5}. L’algoritmo estrae poi il nodo 3 dalla coda ed esegue unpush saturating di 5 unità sull’arco (3, 5), seguito da un’operazione di relabel (figura 3.3(c)). L’algoritmo aggiunge il nodo 3 alla fine della coda, ottenendo LIST={4, 5, 3}.L’algoritmo procede in questo modo finché la coda non sarà vuota.Complessità dell’algoritmoPer analizzare la complessità nel caso peggiore, partizioniamo il numero totale di esami deinodi in fasi differenti. La prima fase consiste nell’esame dei nodi divenuti attivi a causadell’operazione preprocess. La seconda fase consiste nell’esame dei nodi che sono attividopo che l’algoritmo ha esaminato tutti i nodi nella prima fase. Allo stesso modo, la terzafase consiste nell’esame dei nodi attivi che sono in coda dopo che l’algoritmo ha esaminatotutti i nodi nella seconda fase, e così via. Nell’ esempio precedente, la prima fase consistenell’esame dei nodi 2 e 3, la seconda fase consiste nell’esame dei nodi 4, 5 e 3. Notiamoche l’algoritmo esamina un nodo al più una volta durante una fase.2n 2 +n.Lemma 3.6. Il numero di fasi eseguite dall’algoritmo è limitato superiormente daDim. Per limitare il numero di fasi eseguite dall’algoritmo, consideriamo ladifferenza tra i valori iniziale e finale della funzione potenziale Φ=max{ d(i): i è attivo} inun’intera fase. Consideriamo due casi.41

specificato come selezionare un nodo con la più grande distance label in modo efficiente.Per tale selezione, utilizziamo la seguente struttura dati. Per ogni k = 1, 2,…, 2n-1l’algoritmo mantiene la lista LIST(k) = {i: i è attivo e d(i)=k}. Definiamo, inoltre, unavariabile level che rappresenta un limite superiore al più grande valore di k per cui LIST(k)è non vuota. Per determinare un nodo con la più grande distance label, l’algoritmo esaminale liste LIST(level), LIST(level-1), …, finché non individua una lista non vuota, diciamoLIST(p). L’algoritmo pone allora level = p e seleziona un nodo in LIST(p). Inoltre, se ladistance label di un nodo cresce mentre l’algoritmo esamina tale nodo, l’algoritmo ponelevel pari alla nuova distance label del nodo. Notiamo che, per il lemma 3.3, level puòcrescere di al più 2n 2 , per cui il decremento totale che può subire level è al più 2n 2 +n. Diconseguenza, la scansione delle liste LIST(level), LIST(level-1), …, fino ad individuare laprima lista non vuota, non è una operazione onerosa.Cerchiamo ora di capire perché il comportamento dell’algoritmo highest label non èpeggiore dell’algoritmo FIFO, considerando l’esempio dato in figura 3.4 (a). L’operazionedi preprocess creerà un eccesso di un’unità in ognuno dei nodi 2, 3,…, n-1 (vedi figura3.4(b)). L’algoritmo highest label, esaminerà nell’ordine i nodi 2, 3,…, n-1 e trasferiràtutto l’eccesso nel nodo pozzo. L’algoritmo FIFO potrebbe invece eseguire un numeromolto più grande di operazioni di push. Supponiamo che alla fine dell’operazione dipreprocess, la coda dei nodi attivi sia LIST={n-1, n-2,…,3,2}; l’algoritmo allora esamineràognuno di questi nodi nella prima fase ottenendo la rete mostrata in figura 3.4(c).d(i)d(j)(a)8 8 8 8e(i)e(j)(b)8 8 8 8Fig. 3.4. Caso peggiore dell’algoritmo FIFO preflow push. (a): Rete residuainiziale. (b): Rete residua dopo l’operazione di preprocess.43

A questo punto, LIST={n-1, n-2,…, 4, 3}. Non è difficile notare che l’algoritmo eseguiràn-2 fasi, nella prima delle quali eseguirà n-2 push non saturating, nella seconda ne eseguiràn-3 e così via per un totale di Ω(n 2 ) push non saturating.e(i)e(j)(c) 8 8 8 8Fig. 3.4. Caso peggiore dell’algoritmo FIFO preflow push. (c): Rete residua dopouna fase dell’algoritmo.Il precedente esempio illustra il vantaggio di spedire flusso a partire dai nodi con la piùgrande distance label. L’algoritmo highest label inizia con lo spedire flusso dai nodi al piùalto livello, e spedisce gli eccessi in questo livello verso i nodi di livello successivo, edunque ripete tale processo. Così facendo, esso accumula gli eccessi e spedisce tali eccessiaccumulati verso il pozzo. Di conseguenza, l’algoritmo highest label consente di ovviarealle ripetitive spedizioni di quantità piccole di flusso lungo uno stesso arco. Talevantaggiosa caratteristica si traduce in un più stretto limite superiore al numero di push nonsaturating.Complessità dell’algoritmoPrima di mostrare che l’algoritmo esegue O(n 2 m 1/2 ) push non saturating, introduciamoalcune necessarie definizioni. In un qualsiasi istante durante l’esecuzione dell’algoritmopreflow push, ogni nodo diverso dal pozzo, ha al più un current arc che, per definizione,deve essere ammissibile. Denotiamo con F l’insieme dei current arc. L’insieme F ha al piùn-1 archi, al più un arco uscente per nodo, e non contiene alcun ciclo. F pertanto definisceuna foresta, a cui ci riferiremo in seguito come foresta corrente. La figura 3.5 mostra unesempio di foresta. Notiamo che ogni albero nella foresta è un albero radicato, la radice èrappresentata dal nodo che non ha archi uscenti. Per ogni nodoi ∈ N denotiamo con D(i)l’insieme dei discendenti di tale nodo nella foresta F. Per l’esempio in figura 3.5,D(1)={1}, D(2)={2}, D(3)={1, 3, 4}, D(4)={4}, D(5)={1, 2, 3, 4, 5}. Osserviamo che ladistance label di un discendente di i è più grande di d(i). Definiamo nodo attivo massimale44

un nodo attivo che non ha discendenti attivi. I nodi attivi massimali nell’esempioconsiderato sono i nodi 2, 4, e 8. Sia H l’insieme dei nodi attivi massimali. Notiamo chedue nodi attivi massimali non hanno discendenti in comune. Osserviamo inoltre chel’algoritmo highest label spedisce flusso a partire da un nodo attivo massimale.e(i)e(j)Fig. 3.5. Esempio di foresta corrente.Consideriamo ora la funzione potenziale Φ = ∑ ∈Φ( i) , dove Φ (i)è così definito:i HΦ ( i)= max{0, K + 1−| D(i)|} ; K è un parametro che specificheremo in seguito. Notiamoche per ogni i, Φ (i)è al più K in quanto | D ( i)| ≥ 1. Osserviamo inoltre che Φ cambiaogniqualvolta cambia l’insieme H dei nodi attivi massimali o | D ( i)| cambia per un nodomassimale i. Studieremo ora l’effetto dell’esecuzione dell’algoritmo sulla funzionepotenziale Φ , al fine di ottenere un limite al numero di push non saturating. Primo,consideriamo un push non saturating su un arco (i, j) uscente da un nodo attivo massimalei. Un push non saturating avviene su un current arc e non cambia la foresta corrente, essosemplicemente sposta l’eccesso dal nodo i al nodo j (figura 3.6 (a)).Fig. 3.6 (a): Push non saturating sull’arco (3,4).Di conseguenza il nodo i diventa inattivo ed il nodo j potrebbe diventare un nuovo nodoattivo massimale. Poiché | D ( j)| > | D(i)| , tale push decrementa la somma Φ ( i)+ Φ(j)di45

almeno un’unità seD( i)≤ K , altrimenti Φ ( i)+ Φ(j)resta invariata. Consideriamo ora unpush saturating su un arco (i, j) uscente da un nodo massimale i (figura 3.6 (b)). In seguitoa tale push, l’arco (i, j) diventa inammissibile e non appartiene più alla foresta corrente.Fig. 3.6 (b): Push non saturating sull’arco (1,3).Il nodo i è ancora un nodo attivo massimale e il nodo j potrebbe esserlo diventato. Diconseguenza, tale operazione potrebbe incrementare Φ di al più K unità. Esaminiamo oral’operazione di rietichettamento di un nodo attivo massimale i. Il rietichettamento avvienequando il nodo estratto non ha archi ammissibili, pertanto non esiste un current arc uscenteda questo nodo. Di conseguenza, il nodo i deve essere un nodo radice nella forestacorrente. Ma poiché il nodo i è un nodo attivo massimale, nessuno dei suoi discendenti puòessere attivo. Dopo che l’algoritmo ha rietichettato il nodo i, tutti gli archi entranti nel nodoi diventano inammissibili. Pertanto tutti gli archi entranti nel nodo i non apparterranno piùalla foresta corrente (figura 3.6 (c)).Fig. 3.6 (c): Rietichettamento del nodo 5.Tale cambiamento non creerà alcun nuovo nodo massimale, tuttavia il numero di nodidiscendenti di i sarà decrementato ad 1. Di conseguenza, Φ (i)può incrementare di al piùK. Consideriamo infine l’introduzione di un nuovo current arc nella foresta corrente.L’aggiunta di nuovi current arc non crea alcun nuovo nodo attivo massimale, potrebbe anzi46

eliminare qualche nodo attivo massimale incrementando il numero di discendenti di undato nodo (figura 3.6 (d)).Fig. 3.6 (d):Aggiunta dell’arco (3,5) alla foresta.In ogni caso la funzione potenziale Φ non incrementa. Abbiamo dunque stabilito laseguente:Proprietà 3.8.a) Un push non saturating da un nodo attivo massimale i non incrementa Φ ; essodecrementa Φ di almeno un’unità se D( i)≤ K .b) Un push saturating da un nodo attivo massimale i può incrementare Φ di alpiù K unità.c) Il rietichettamento di un nodo attivo massimale i può incrementare Φ di al piùK unità.d) L’introduzione di current arc non incrementa Φ .Definiamo ora il concetto di fase. Una fase è costituita dalla sequenza di push tra dueconsecutive operazioni di relabel. Il lemma 3.3 implica che l’algoritmo eseguirà O(n 2 ) fasi.Diremo che una fase è economica se il numero di push non saturating in essa eseguiti èlimitato superiormente da 2n/K, altrimenti diremo cha la fase è espansiva. Ovviamente ilnumero di push non saturating in fasi economiche è al più O(n 2 • 2n/K)=O(n 3 /K). Perdefinizione, in una fase espansiva vengono eseguiti almeno 2n/K push non saturating.Poiché la rete può contenere al più n/K nodi con K discendenti o più, almeno n/K push nonsaturating devono verificarsi tra nodi con meno di K discendenti. L’algoritmo highest labelpreflow push effettua operazioni di push e relabel su nodi attivi massimali, possiamopertanto applicare la proprietà 3.8, la quale implica che ognuno di tali push non saturating47

deve decrementare Φ di almeno un’unità. Le parti (b) e (c) della precedente proprietàimplicano che il totale incremento in Φ dovuto ad operazioni di push saturating e relabel èal più O(nmK). Di conseguenza, l’algoritmo può eseguire O(nmK) push non saturating inua fase espansiva.Ricapitolando la precedente discussione, notiamo che nella fase economica vengonoeseguiti O(n 3 /K) push non saturating e nella fase espansiva O(nmK). Otteniamo il valoreottimo di K bilanciando (vedi appendice A.2) entrambi i termini, ovvero quando i terminisono uguali: n 3 /K =nmK, da cui K= n/m 1/2 . Per tale valore di K il numero di push nonsaturating è O(n 2 m 1/2 ). Abbiamo pertanto stabilito il seguente:Teorema 3.9. L’algoritmo highest label preflow push esegue O(n 2 m 1/2 ) push nonsaturating ed il suo tempo d’esecuzione è O(n 2 m 1/2 ).48

Capitolo 4Algoritmo AuctionPresentiamo ora un algoritmo che può essere considerato un approccio ibrido tra i metodidiscussi precedentemente, in quanto sfrutta concetti sia degli algoritmi augmenting path,sia degli algoritmi preflow-push. Esso individua augmenting path nella rete residua dilunghezza non necessariamente minima. L’idea alla base di tale metodo è che l’invio diflusso verso il pozzo necessita semplicemente di un direct path da s a t nella rete residua el’insistenza nell’individuazione di un direct path di lunghezza minima può implicare unconsiderevole costo computazionale. Dopo aver descritto tale metodo, estenderemo lalogica alla base di tale algoritmo, proponendo un algoritmo dagli interessanti risultatipratici.4.1 Path construction algorithmDescriviamo ora un metodo per individuare un direct path tra due nodi di un grafo G=(N,A). Tale metodo è alla base dell’algoritmo per il massimo flusso che presenteremo nelparagrafo 4.3.Ricordiamo, dalle definizioni date nel capitolo primo, che un direct walk P è una sequenzadi nodi (i 1 , i 2 , …, i r ) con r ≥ 2, ed una corrispondente sequenza di r-1 archi tali che l’i-moarco nella sequenza è l’arco (i i, i i+1 ); i 1 è il nodo iniziale del walk, i r è il nodo terminale.L’algoritmo che presentiamo consente di individuare un direct path, ovvero un direct walksenza alcuna ripetizione di nodi, che inizia ad un dato nodo i 1 ed ha come nodo terminaleun nodo t. Esso mantiene un direct walk P=(i 1 , i 2 , …, i r ) ed un vettore di interi p dove p(i)rappresenta il “prezzo” associato al nodo i. Il direct walk P ed il vettore p soddisfano leseguenti condizioni:1. p( i)≤ p(j)+ 1 ∀ ( i,j)∈A, (4.1)49

2. p(i 1 ) < n, p (t)= 0, (4.2)3. p( i)≥ p(j)∀ ( i,j)∈P. (4.3)L’algoritmo è motivato dal contesto del massimo flusso, dove l’obiettivo non è individuareun singolo path, ma una sequenza di path ognuno dei quali in un grafo che differisceminimamente dal suo predecessore; infatti la rete residua dopo un aumento su undeterminato augmenting path, differirà solo leggermente dalla stessa rete residua primadell’operazione di aumento. In tale contesto, i prezzi associati ai nodi risultano utili nelguidare la ricerca per nuovi path. Il vettore dei prezzi è infatti modificato dall’algoritmo inmodo tale che i path desiderati sono diretti approssimativamente verso il basso, nel sensoche essi procedono da nodi con prezzo maggiore verso nodi con prezzo minore. Pertanto,se un determinato insieme di prezzi è appropriato per guidare la ricerca in un dato grafo,esso sarà approssimativamente appropriato per guidare la ricerca di un path in un grafoleggermente differente. All’inizio dell’algoritmo, il direct walk P è costituito (con un abusodi notazione) dal solo nodo i 1 , ed il vettore p è tale da soddisfare le condizioni (4.1) e (4.2)sopraelencate (una possibile inizializzazione per p è p ( i)= 0 ∀ i ∈ N ). Il direct walk P èmodificato utilizzando le seguenti due operazioni:a) Una contrazione di P, che elimina l’ultimo arco di P, ovvero sostituisce il walkP=(i 1 , i 2 , …, i t-1 , i t ) con il walk P=(i 1 , i 2 , …, i t-1 ). Nel caso particolare in cui P=(i 1 ),l’operazione di contrazione non modifica P.b) Una estensione di P, che aggiunge al walk P un arco uscente dal suo nodoterminale, ovvero sostituisce il walk P=(i 1 , i 2 , …, i t ) con un walk P=(i 1 , i 2 , …, i t ,i t+1 ), dove (i t , i t+1 ) ∈ A(i t ).50

algorithm path constructionbeginP=(i 1 );i t =i 1 ;Seleziona un vettore p che soddisfi le condizioni (4.1) e (4.2);while(TRUE)beginif N(i t ) = ∅ thenp(i t ):=n;Contract(P);elsebeginsucc(i t ):= argminp(j) ;j∈N(it)p(i t ):=p(succ(i t )) + 1;if i t = i 1 OR p(pred(i t )) > p(succ(i t )) then Extend(P, succ(i t ));else Contract(P);end;end;end;procedure Extend(P, j)beginSostituisci P=(i 1 , i 2 , …, i t ) con P=(i 1 , i 2 , …, i t , j);if j=t then terminate;end;procedure Contract(P,j)begin51

if P=(i 1 ) AND p(i 1 ) ≥ n then terminate;Sostituisci P=(i 1 , i 2 , …, i t-1 , i t ) con P=(i 1 , i 2 , …, i t-1 );end;Diamo ora un esempio del funzionamento dell’algoritmo, per poi passare ad evidenziarnealcune fondamentali proprietà.(a)(b)Fig. 4.1. Esempio di funzionamento dell’algoritmo path construction.(a): Rete iniziale. (b): Rete al termine dell’algoritmo.All’ inizio dell’Walk Piterazione #Vettore dei prezzi p Operazione effettuata1 P=(1) (0,0,0,0,0,0,0) Estensione su 2.2 P=(1,2) (1,0,0,0,0,0,0) Estensione su 3.3 P=(1,2,3) (1,1,0,0,0,0,0) Estensione su 5.4 P=(1,2,3,5) (1,1,1,0,0,0,0) Contrazione, N(5)= ∅ .5 P=(1,2,3) (1,1,1,0,7,0,0)Contrazione,p(pred(3))

All’ inizio dell’Walk Piterazione #Vettore dei prezzi p Operazione effettuata9 P=(1) (1,9,8,8,7,0,0) Estensione su 6.10 P=(1,6) (1,9,8,8,7,0,0)Estensione su 7. n t =7,Stop.Proprietà 4.1. I prezzi restano interi durante l’esecuzione dell’algoritmo.Ovvio, in quanto in fase di inizializzazione, il vettore p è scelto come vettore diinteri e l’unica operazione che modifica i prezzi è l’aggiornamento del prezzo di p(i t ) nelcorpo del ciclo while dell’algoritmo, ovvero p(i t )=p(succ(i t )) + 1.Proprietà 4.2. Le condizioni (4.1), (4.2) e (4.3) sono soddisfatte ogniqualvoltal’algoritmo entra nel ciclo while.La condizione (4.2) è banalmente mantenuta vera durante l’esecuzionedell’algoritmo, in quanto l’algoritmo termina quando la condizione (4.2) non è più vera,ovvero quando p(i 1 ) ≥ n.Dimostriamo la proposizione per induzione sul numero di volte in cui l’algoritmo entra nelciclo while. Le condizioni (4.1) e (4.3) valgono, per base d’induzione, all’iniziodell’algoritmo. Consideriamo una generica iterazione dell’algoritmo, e supponiamo che nelmomento in cui l’algoritmo entra nel ciclo while, le condizioni (4.1) e (4.3) valgono.Dimostriamo che tali condizioni valgono all’inizio della successiva iterazione. Notiamoche nel corpo del ciclo while, solo il prezzo di i t può cambiare. Ed in particolarel’algoritmo pone p(i t )=p(succ(i t )) + 1; ma succ(i t )= arg min p(j), il che implicap(succ(i t )) ≤ p( j)∀ j∈N ( it)e dunque p(i t )=p(succ(i t )) + 1 ≤ p( j)+ 1 ∀ j∈N( it)pertantoj ∈N(it)53

la condizione (4.1) viene soddisfatta per ogni arco, compreso l’arco (i t, succ(i t )).Consideriamo ora la condizione (4.3): poiché p(i t ) viene modificato, l’arco (pred(i t ) , i t )potrebbe violare tale condizione. Notiamo però che successivamente alla modifica di p(i t )si ha una contrazione o una estensione. Nel caso della contrazione, i t viene eliminato dalwalk, quindi l’arco (pred(i t ) , i t ) ∉ P . L’estensione avviene invece quando p(pred(i t )) >p(succ(i t )), essendo i prezzi interi, la precedente disuguaglianza è equivalente ap(pred(i t )) ≥ p(succ(i t ))+1, ma p(succ(i t ))+1 = p(i t ), pertanto la condizione (4.3) èsoddisfatta per ogni arco del path P.Proprietà 4.3. Una contrazione determina un aumento di prezzo.Sia i t il nodo terminale del direct walk P e supponiamo che l’algoritmo stia perentrare nel corpo del ciclo while. Per la proposizione precedente, prima di entrare nel ciclo,vale la condizione (4.3), per cui p(pred(i t )) ≥ p(i t ). Affinché vi sia una contrazione nel ciclowhile, p(pred(i t )) ≤ p(succ(i t )), da cui p(i t ) ≤ p(succ(i t )). Ma l’algoritmo precedentemente haposto p(i t )=p(succ(i t )) + 1, incrementando il valore di p(i t ).Non è detto invece che un’estensione sia accompagnata sempre da un incremento diprezzo, come è possibile notare dall’iterazione numero 9 dell’esempio precedente.Archi uphill e downhill. Dati un vettore p di prezzi interi, diremo che un arco ( i , j)èuphill se p (i) < p(j), downhill se p( i)≥ p(j)e strettamente downhill se p ( i)= p(j)+ 1.Proprietà 4.4. Il direct walk P è un direct path , ed in seguito ad un’estensione,l’ultimo arco di P è strettamente downhill.Sia P=(i 1 , i 2 , …, pred(i t ), i t ). Dalla condizione (4.3) si ha chep( i)≥ p(j)∀ ( i , j)∈Ρ. Supponiamo, per assurdo, che l’algoritmo si estenda su un nodo54

succ(i t ) appartenente a P. L’estensione avviene quando p(pred(i t ))>p((succ(i t )), ma poichésucc(i t )∈Psi ha: p(pred(i t ))>p((succ(i t )) ≥ p(pred(i t )), assurdo.Ner ritornare nel corpo del while in seguito ad un’estensione, l’algoritmo ha postop(pred(i t ))=p(i t )+1, dunque l’ultimo arco di P, in seguito ad un’estensione, è strettamentedownhill.Dalle proposizioni precedenti deriva il seguenteTeorema 4.5. Durante l’esecuzione dell’algoritmo, il vettore dei prezzi soddisfa lecondizioni (4.1) e (4.2), il direct walk P è un direct path, i suoi archi sono downhill(condizione (4.2)), ed in seguito ad un’estensione, l’ultimo arco di P è strettamentedownhill.Dimostriamo ora il seguenteTeorema 4.6. Se esiste un direct path da i 1 a t, l’algoritmo termina in seguito adun’estensione con tale path. Altrimenti, l’algoritmo termina in seguito ad una contrazione.Dim. Dimostriamo innanzitutto che l’algoritmo termina. Notiamo che, durantel’esecuzione dell’algoritmo, i prezzi dei nodi in P sono strettamente minori di n. Infatti, seesistesse un nodo nel path P con un prezzo almeno n, la condizione (4.3) che vale durantel’esecuzione dell’algoritmo, implicherebbe p(i 1 ) ≥ n, che causerebbe la terminazionedell’algoritmo. Inoltre in corrispondenza di ogni contrazione si ha un incremento di prezzodi almeno un’unità, ed essendo i prezzi dei nodi in P limitati da n, il numero di contrazioniè finito. Osserviamo che tra una contrazione e quella successiva possono esistere al più n-1estensioni consecutive. Infatti se ne esistessero più di n-1, significherebbe che l’algoritmosi è esteso su un nodo che già appartiene a P, ma per quanto dimostrato precedentementequesto non è possibile. Dunque essendo il numero di contrazioni limitato, e tra unacontrazione e l’altra può esserci un numero limitato di estensioni, l’algoritmo termina.55

Dimostriamo ora che se l’algoritmo termina in seguito ad una contrazione, non esiste unpath da i 1 a t. Dalla proprietà 4.2, si ha che durante l’esecuzione dell’algoritmo, p(t)=0 ep ( i)≤ p(j)+ 1 ∀ ( i , j)∈Α . Dunque se esiste un direct path da i 1 a t, p(i 1 ) < n. Infatti undirect path da i 1 a t può contenere al più n - 1 archi e poiché per ogni arco vale chep ( i)≤ p(j)+ 1, p(i 1 ) può essere al più n - 1. Pertanto, se l’algoritmo termina in seguito aduna contrazione, il che avviene quando p(i 1 ) ≥ n, non esiste un direct path da i 1 a t.4.2 Miglioramento dell’algoritmo path constructionNel precedente algoritmo buona parte dell’elaborazione è necessaria, dato il nodoterminale i t di un path P, ad individuare il nodo succ(i t ) in corrispondenza del quale si ha ilminimo peso tra i nodi adiacenti ad i t . Tuttavia, è possibile che per un determinato nodoesistano più nodi adiacenti con uno stesso valore minimo. Ha senso, pertanto, memorizzaretali nodi (ad i relativi archi) in una struttura dati e cercare di riutilizzarla per quantopossibile senza modificare le essenziali proprietà dell’algoritmo, ovvero il soddisfacimentodelle condizioni (4.1), (4.2), e (4.3), e la garanzia che il walk P sia costituito da nodidistinti. Per sfruttare tale idea, l’algoritmo mantiene per ogni nodo i ≠ t, un sottoinsiemedegli archi uscenti da i denotato Cand(i) che chiameremo l’insieme candidato degli archidel nodo i. L’insieme dei nodi terminali degli archi in Cand(i), sarà denotato con Succ(i).L’insieme Cand(i) ed il vettore dei prezzi p(i) definiscono un grafo, che chiameremo ilgrafo ammissibile, il cui insieme dei nodi è N, ovvero lo stesso insieme dei nodi del grafodi partenza, e l’insieme degli archi è A = {(i, j) | j ∈succ(i), p(i) ≥ p(j), i∈ N }.Durante l’esecuzione dell’algoritmo al variare degli insiemi Succ(i) e dei prezzi p(i) varia ilgrafo ammissibile che tuttavia resta aciclico, come dimostreremo in seguito, fino al terminedell’ algoritmo. Inizialmente l’insieme Cand(i) e il vettore dei prezzi p(i) sono tali che ilgrafo ammissibile è aciclico. Tale condizione è banalmente soddisfatta se Cand(i)=∅ ∀i∈ N e p ( i)= 0 ∀ i ∈ N .56

algorithm modified path constructionbeginP:=(i 1 );i t :=i 1 ;Seleziona un vettore p che soddisfi le condizioni (4.1) e (4.2);while(TRUE)beginif esiste un nodo l∈ Succ(i t ) tale che p(i t ) ≥ p(l) then Extend(P,l);elsif N(i t ) = ∅ thenp(i t ):=n;Contract(P);elsebeginSucc(i t ):={ l |p(l) = minp(j) };j∈N(it)Cand(i t ):={(i t , l) ∈ A(i t ) | l∈ Succ(i t )};Seleziona un nodo l∈ Succ(i t );p(i t ):=p(l) + 1;if i t = i 1 OR p(pred(i t )) > p(l) then Extend(P,l);else Contract(P);end;end;end;Consideriamo ora un esempio di funzionamento dell’algoritmo,in cui il vettore p è statoscelto come p=(0, 0, 0, 0, 1, 0), al fine di evidenziare l’utilità degli insiemi ausiliariSucc(i) e Cand(i).57

(a)(b)Fig. 4.2 Esempio di funzionamento dell’algoritmo path construction migliorato.(a): Situazione iniziale. (b): Al termine dell’algoritmo.# Path PVettore deiprezzi p(Succ(1),Succ(2),…, Succ(6)) Operazioni effettuate1 P=(1) (0,0,0,0,1,0) (∅ ,∅ ,∅ ,∅ ,∅ ,∅ )Costruzione Succ(1),estensione su 2.2 P=(1,2) (1,0,0,0,1,0) ({2,3},∅ ,∅ ,∅ ,∅ ,∅ )Costruzione Succ(2),estensione su 4.3 P=(1,2,4) (1,1,0,0,1,0) ({2,3},{4},∅ ,∅ ,∅ ,∅ ) Contrazione, N(4)= ∅ .4 P=(1,2) (1,1,0,6,1,0) ({2,3},{4},∅ ,∅ ,∅ ,∅ )Ricostruzione Succ(2),contrazione,p(pred(2))

La maggior efficienza di tale versione relativamente alla precedente è dovuta almantenimento degli insiemi Succ(i t ) e Cand(i t ). Si consideri l’iterazione 5 del precedenteesempio. Come è possibile notare, l’algoritmo estende il path P=(1) sul nodo 3. Conun’opportuna implementazione, l’individuazione del nodo su cui deve essere esteso il pathè effettuata in tempo costante; mentre nella versione precedente sarebbe stato necessarioanalizzare nuovamente i vicini del nodo 1 per individuare il nodo con prezzo minimo. Inmodo simile alla prima versione dell’algoritmo, ogni contrazione è accompagnata da unincremento del prezzo p(i t ). Ed ancora analogamente, un’estensione può essereaccompagnata o meno da un incremento di prezzo. Le due versioni dell’algoritmodifferiscono invece nel test effettuato al fine di effettuare un’operazione di estensione. Inparticolare, nella seconda versione di tale algoritmo, viene effettuata un’estensione su unnodo l∈Succ(i t ) anche quando p(i t ) = p(l), causando che l’ultimo arco di P non siastrettamente downhill in seguito ad un’estensione, cosi come avviene nella prima versione.Per tale motivo non è ovvio che un’estensione non creerà un ciclo nel walk P. Perdimostrare che il direct walk P è direct path , dimostriamo le seguenti proposizioni.Proprietà 4.7. Gli archi di P appartengono al grafo ammissibile.E’ necessario dimostrare che ∀ ( i , j)∈Ρ: j∈Succ(i) e p( i)≥ p(j). Dimostriamo talerisultato per induzione sul numero di operazioni di estensione e contrazione che possonoessere eseguite su P. In particolare dimostriamo che se P appartiene al grafo ammissibile eviene eseguita un’operazione di contrazione o estensione, il walk risultante appartieneancora al grafo ammissibile.Se l’operazione subita da P è una contrazione, questa elimina solo l’arco terminale di P,lasciando inalterati i prezzi dei nodi terminali degli altri archi in P. Pertanto se P=(i 1 , i 2 , …,i t ) è il walk prima della contrazione e∀ ( i , j)∈Ρ: j∈Succ(i) e p( i)≥ p(j), tale condizionevale anche per il walk P’=(i 1 , i 2 , …, i t-1 , i t ) dopo la contrazione. Consideriamo oral’operazione di estensione. Tale operazione aggiunge al path P un arco di Cand(i t ), e siaquando il test p(i t ) ≥ p(l) è soddisfatto, sia quando p(i t ) è settato a p(l) + 1, l’arco (i t , l) èdownhill, ovvero p(i t ) ≥ p(l).59

aciclico.Proprietà 4.8. Durante l’esecuzione dell’algoritmo, il grafo ammissibile restaNella fase d’inizializzazione Cand(i) e p(i) sono scelti in modo tale che il grafoammissibile sia aciclico. Dunque la base d’induzione vale per costruzione. Consideriamouna generica iterazione e ipotizziamo che il grafo ammissibile sia aciclico all’inizio delcorpo del ciclo while. Dimostriamo che il grafo è aciclico all’inizio della successivaiterazione. Distinguiamo due casi in base al fatto che esista o meno un nodo l∈ Succ(i t )soddisfacente il test p(i t ) ≥ p(l). Se tale nodo l esiste, il grafo ammissibile non è modificatonel ciclo while. Nel secondo caso, viene nuovamente calcolato l’insieme Cand(i t ), che puòora contenere archi che precedentemente non appartenevano al grafo ammissibile,causando eventualmente un ciclo. Dopo aver calcolato Cand(i t ), l’algoritmo ponep(i t )=p(l) + 1, e quindi tutti gli archi in Cand(i t ) sono strettamente downhill, ovverop(i t )=p(l) + 1 ∀ l∈ Succ(i t ). Ma allora tali archi non possono essere parte di un ciclo nelgrafo ammissibile, in cui, per definizione, tutti gli archi sono downhill. Ovverosupponiamo per assurdo che esista un arco strettamente downhill (i t , l) in Cand(i t ) cherende il grafo ammissibile ciclico. Affinché tale arco chiuda il ciclo, esiste nel grafoammissibile un percorso da l ad i t . Ma il grafo ammissibile è costituito da archi downhill,ovvero p(l) ≥ p(i t )=p(l) + 1> p(l), assurdo.Dunque gli archi di P appartengono al grafo ammissibile, che durante l’esecuzionedell’algoritmo è aciclico, pertanto P è un direct path. Riassumiamo tali proprietà nelseguenteTeorema 4.9. Assumiamo che inizialmente il grafo ammissibile sia aciclico. Allora:a) Durante l’esecuzione dell’algoritmo, il grafo ammissibile resta aciclico.b) Il vettore dei prezzi soddisfa le condizioni (4.1) e (4.2), il walk P è un direct walk, egli archi di P sono downhill.c) Se esiste un direct path da i 1 a t, l’algoritmo termina in seguito ad un’estensionecon tale path. Altrimenti, l’algoritmo termina in seguito ad una contrazione.60

Dim. La parte (a) deriva dalla proprietà 4.8, (b) e (c) derivano dalla proprietà 4.7 e daiteoremi 4.5 e 4.6.4.3 Algoritmo principalePrima di passare alla descrizione dell’algoritmo, introduciamo alcune definizioni.Ricordiamo, dalle definizioni date nel capitolo 1, che data una rete capacitata G=(N, A) edun flusso x (o un preflow x) la rete residua indotta da x è il grafo G(x)=(N, A’) doveA’={(i, j) ∈ NxN : r ij >0}. Dato un preflow x, definiamo per ogni nodo i, l’insieme degliarchi eleggibili di i come A( i,x)= {( i,j)| ( i,j)∈ A'}, dove A’ è l’insieme degli archi dellarete residua indotta da x. Noto A ( i,x), definiamo l’insieme dei vicini eleggibili di i comeN( i,x)= {( i,j)| ( i,j)∈ A(i,x)}.L’algoritmo che presentiamo in tale paragrafo termina con un preflow x ed un taglio saturo[ S , S]tali che gli eccessi e(i) soddisfano le condizioni:e ( s)≤ 0 , e( i)≥ 0 ∀ i ≠ s , e( i)= 0 ∀ i ∈ S,i ≠ t . (4.4)Successivamente dimostreremo che tale taglio è un taglio minino e mostreremo come essopuò essere utilizzato insieme ad x per costruire un massimo flusso. Diremo che un preflowx ed un vettore dei prezzi p= { p(i)| i ∈ N}costituiscono una coppia valida sep( i)≤ p(j)+ 1 ∀ j ∈ N(i,x). (4.5)L’algoritmo inizia con una coppia valida (x, p) tale chee ( s)≤ 0 , e( i)≥ 0 ∀ i ≠ s , (4.6)p ( s)= n , p ( t)= 0 , p ( i)≥ 0 ∀ i ≠ s,t . (4.7)Una possibile scelta iniziale è costituita dal preflow x dato da:x ij = uij se i = s, ij = 0x se i ≠ s (4.8a)e dal vettore dei prezzi p dato da:p ( i)= n se i = s, p (i) = “lunghezza di uno shortest direct path da i a t” se i ≠ s. (4.8b)61

Notiamo che la lunghezza di uno shortest direct path da i a t può essere ottenutaeffettuando una visita in ampiezza nella rete residua a partire dal nodo pozzo. L’algoritmomantiene una coppia valida (x, p) soddisfacente le condizioni 4.5, 4.6 e 4.7, esegue unasequenza di iterazioni, e termina con un taglio minimo. All’inizio di ogni iterazione vieneselezionato un nodo i1 ≠ t tale che p ( i1 ) < n e e ( i1 ) > 0 . L’algoritmo cerca dunque dicostruire un augmenting path a partire da i 1 utilizzando l’algoritmo path constructiondescritto precedentemente applicato alla rete residua, utilizzando il vettore di prezzi p. Sel’algoritmo riesce ad individuare un augmenting path, esso aumenta il flusso lungo talepath. Se non è possibile individuare un augmenting path a partire da i 1 , l’algoritmo pathconstruction terminerà con p( i1 ) ≥ n , in modo tale che i 1 non sarà scelto in iterazionisuccessive. Analogamente all’algoritmo path construction, l’algoritmo mantiene per ogninodo i, un insieme di archi incidenti in i, denotato con Cand(i). Tale insieme è vuoto peri = s , i = t, e per tutti i nodi i con p ( i)= n . Denotiamo con Succ(i) l’insieme dei nodi diCand(i) opposti ad i. L’algoritmo richiede che inizialmente p ( i)= p(j)+ 1 se j ∈ Succ(i),il che sarà vero se tutti gli insiemi Cand(i) sono vuoti, oppure se per ogni nodo i abbiamoCand(i)= {( i,j)∈ A(i,x)| p(i)= p(j)+ 1} U {( j,i)∈ A(i,x)| p(i)= p(j)+ 1}, (4.9)dove (x, p) è la coppia valida iniziale. Se utilizziamo l’inizializzazione specificata nelle(4.8a) e (4.8b), allora Cand(i) come specificato dall’equazione (4.9), è l’insieme degli archiuscenti da i in uno shortest augmenting path a partire da i. Specifichiamo formalmentel’algoritmo.procedure Extend(P, j)beginsostituisci P=(i 1 , i 2 , …, i t ) con P=(i 1 , i 2 , …, i t , j);if j=t then Augment;end;procedure Contract(P, j)beginif P=(i 1 ) AND p(i 1 ) ≥ n then termina l’iterazione del ciclo while;sostituisci P=(i 1 , i 2 , …, i t-1, i t ) con P=(i 1 , i 2 , …, i t-1 );end;62

algorithm Auction/Max-Flowbeginseleziona una coppia (x, p) che soddisfi le condizioni (4.6) e (4.7);while esiste un nodo i 1beginseleziona un nodo i 1P:=(i 1 );i t := i 1 ;while (TRUE)begin≠ t tale che e(i 1 ) > 0 e p(i 1 ) < n do≠ t tale che e(i 1 ) > 0 e p(i 1 ) < n;if esiste j ∈ Succ(it)I N(it ,x)tale che (i ) p(j)Extend(P, j );p t ≥ then (4.10)elsifN(it ,x) = ∅ thenelsebeginp(it) :=n;Contract(P);Succ(i t ):={ j |p(j) = minp(j) }; (4.11)j ∈N(it,x)Cand(i t ):= {( it,j) A(it,x)| j ∈ Succ(it)}U∈ (4.12)U {( j,it) ∈ A(it,x)| j ∈ Succ(it)};seleziona j∈Succ(n t );p(i t ):= (j) + 1p ; (4.13)if i t = i 1 OR p(pred(i t )) > p (j)then Extend(P, j );else Contract(P);end;end;end;end;procedure Augmentbeginδ= 1min{ e(i ),min{rij | (i, j) ∈ P}};aumenta di δ unità il flusso lungo P e termina l’iterazione;end;63

Stabiliamo ora le proprietà di base di tale algoritmo con il seguente:Teorema 4.10.a) Ogni iterazione dell’algoritmo auction max/flow fino all’individuazione delcorrispondente augmenting path, consiste di un’applicazione dell’algoritmopath construction (seconda versione) alla rete residua, dove il nodo iniziale delpath è il nodo i 1 estratto in tale iterazione, ed il nodo terminale del path è ilnodo pozzo t.b) L’algoritmo termina, ed al termine esiste un taglio saturo che separa il nodopozzo da tutti i nodi con eccesso maggiore di zero. Tale taglio è un tagliominimo.c) Il tempo d’esecuzione dell’algoritmo é O(n 2 m) .Dim. (a) Confrontando le descrizioni dell’algoritmo path construction e l’iterazionedell’algoritmo auction, notiamo che la condizione (4.1) mantenuta vera dall’algoritmo pathconstruction, è equivalente alla condizione (4.5) che deve essere soddisfatta affinché lacoppia (x, p) sia valida. Notiamo ancora che il cambiamento di prezzo p(i t )= p ( j)+ 1dell’algoritmo path construction corrisponde al cambiamento di prezzo (4.13) ed il testp( it)≥ p(j)corrisponde al test (4.10). Definiamo grafo ammissibile dell’algoritmo maxflowil grafo il cui insieme dei nodi è N e il cui insieme degli archi è{( i,j)| j ∈ Succ(i)I N(i,x),p(i)≥ p(j),∀ i ∈ N}. Gli insiemi Succ (i)e il grafoammissibile visti nell’algoritmo per la costruzione del cammino, corrispondonorispettivamente all’ insieme Succ( i)I N(i,x)e al grafo ammissibile dell’algoritmo maxflow.Basandoci sulle associazioni precedenti, è possibile notare che se all’inizio di unaiterazione dell’algoritmo max-flow il grafo ammissibile è aciclico, allora l’iterazionedell’algoritmo fino all’individuazione dell’augmenting path è equivalente all’applicazionedell’algoritmo path construction alla rete residua. Dunque per provare il risultato dobbiamomostrare che il grafo ammissibile dell’algoritmo max-flow resta aciclico durantel’esecuzione dell’algoritmo.64

Data la restrizione iniziale p( i)= p(j)+ 1 ∀ j ∈ Succ(i), il grafo ammissibile è aciclicoall’inizio dell’algoritmo. Inoltre, se il grafo ammissibile è aciclico all’inizio di unaiterazione, resta tale fino all’individuazione dell’augmenting path, poiché l’algoritmo pathconstruction preserva l’aciclicità del grafo ammissibile. Dimostriamo che un’operazione diaumento non aggiunge archi nuovi al grafo ammissibile, mantenendo la proprietà diaciclicità. Supponiamo che un aumento si verifichi lungo il cammino (i 1 , i 2 , …, i k , t) e cheuno degli archi (i m , i m-1 ), con m=2, …, k, sia aggiunto alla rete residua e al grafoammissibile in seguito ad un aumento. Allora, si ha che p ( im)≥ p(im− 1), conim− 1∈ Succ(im)(per definizione di grafo ammissibile), e p( im− 1)≥ p(im)coni m ∈ Succ( im− 1) (poiché, l’arco (i m–1 , i m ) appartiene all’ augmenting path), da cuip ( im− 1)= p(im). Questo implica che p ( im − 1)e p ( im)sono stati incrementati almeno unavolta dall’inizio dell’algoritmo (poiché abbiamo p( i)= p(j)+ 1 ∀ j ∈ Succ(i)sia all’iniziodell’algoritmo sia dopo aver ricalcolato l’insieme Succ (i)). Tuttavia, le condizionip ( im− 1 ) < p(im)+ 1 e i m ∈ Succ( im− 1)implicano che l’ultimo incremento di p ( im)èaccaduto dopo l’ultima volta che è stato ricalcolato Succ ( im − 1)(questo perché in seguito alcalcolo di Succ (i), si ha p ( i)= p(j)+ 1 ∀ j ∈ Succ(i)). Dunque l’ultimo incremento dip ( im)ha luogo dopo l’ultimo incremento di p ( im − 1)(poiché ogni incremento di p (i)comporta il calcolo di Succ (i)). Allo stesso modo, le condizioni p ( im)< p(im − 1 ) + 1 eim− 1∈ Succ(im)implicano che vale anche l’opposto, raggiungendo in tal modo unacontraddizione.(b) Dalla parte (a) e dal teorema 4.9, segue che ogni iterazione per ladeterminazione dell’augmenting path termina. Infatti, alla fine di una iterazione, si hap(i 1 ) ≥ n, il che ad indicare che non esiste nessun augmenting path da i 1 a t, oppure si ha unaumento. Nel primo caso il numero di nodi i con p(i) ≥ n aumenta strettamente, pertantopossono esistere al più n-2 iterazioni di questo tipo. Per mostrare che il numero di aumentiè finito, notiamo che il prezzo di ogni nodo può essere incrementato al più n volte, e poichéi prezzi assumono valori interi non negativi, quando il prezzo di un nodo eccede n-1 talenodo non verrà più incrementato. Osserviamo che ogni aumento o esaurisce l’eccesso di i 1 ,oppure satura almeno un arco. Quando un arco di estremi i e j è saturato nella direzione dai a j, si presentano due possibilità: p ( i)= p(j)+ 1, oppure p ( i)= p(j). Nel secondo caso,poiché j ∈ Succ(i)non è possibile che i ∈ Succ( j), altrimenti si violerebbe l’aciclicità del65

grafo ammissibile. In entrambi i casi si ha che uno degli al più n incrementi di p ( j)deveverificarsi prima che l’arco possa diventare non saturo e poi saturato ancora nella direzioneda i a j. Così il numero di saturazioni di un arco è O(n) e il numero totale di saturazioni èO(nm), che stabilisce il limite O(nm) sul numero di iterazioni e sul numero di aumenti. Daciò segue che l’algoritmo termina. Poiché gli aumenti preservano la condizione e(i)≥0 perogni i ≠ s, al termine dell’algoritmo dobbiamo avere e ( i)≥ 0 per ogni i ≠ s, p ( s)= n ,p( i)≥ n per ogni i ≠ t con e ( i)≥ 0 , ep( t)= 0 . Segue che non possono esistereaugmenting path che iniziano dal nodo s o da un nodo i con e ( i)≥ 0 , il che implical’esistenza di un taglio saturo [ S , S]tale che s ∈ S , t ∈ S , e( i)≥ 0 ∀ i ≠ s ,e( i)= 0 ∀ i ∈ S,i ≠ t . Come detto in precedenza, tale taglio è un taglio minimo.(c) Nel punto (b) abbiamo dimostrato che:1. Esistono al più n incrementi di prezzo per un dato nodo.2. Esistono O(nm) iterazioni e O(nm) operazioni di aumento.Dal punto 1 precedente, si hanno al più n contrazioni ed estensioni che implicano unaumento del prezzo di ogni nodo, ed il tempo per l’estensione e la contrazione èproporzionale al grado di i t. Così il tempo totale è O(nm). Inoltre, poiché ogni operazione diaumento implica un cambiamento del flusso su ciascuno degli al più n-1 archi, il tempo pergli aumenti è O(n 2 m).Resta da stabilire un limite al tempo necessario alle estensioni che non implicano unaumento del prezzo. Dimostriamo, per assurdo, che ognuna di tali estensioni non implicache Succ ( it)debba essere ricalcolato, ovvero, un’estensione di questo tipo implica ilcalcolo di Succ ( it)per la prima volta, oppure implica che il test (4.10) è non soddisfattoper ogni j ∈ Succ( it)I N( it , x). Supponiamo allora che l’insieme Succ ( it)sia ricalcolatocome specificato nell’equazione (4.11) e che valga la condizionep( it)= p(j)+ 1 ∀ j ∈ Succ(it)in modo tale che un’estensione sia effettuata senza alcunincremento di p ( it). Allora, ogni j ∈ Succ( it)doveva essere un vicino eleggibile di i t ed ilsuo prezzo è rimasto inalterato dall’ultimo calcolo di Succ ( it). Ma ciò è unacontraddizione, in quanto affinché Succ ( it)venga ricalcolato, tutti i nodi j nell’insiemeSucc( it)I N( it , x)devono soddisfare p( it ) < p(j). Dunque se una estensione da i t noncausa un aumento del prezzo p ( it), essa non implica che Succ ( it)debba essere ricalcolato.66

Pertanto, con un’opportuna implementazione di Succ ( it), tale estensione richiede tempoO(1), a meno che essa non coinvolga il calcolo di Succ ( it)per la prima volta. Il numerototale di estensioni è O(n 2 m) perché in ogni iterazione, il numero di estensioni eccede ilnumero di contrazioni di al più n - 1; il numero totale di contrazioni durante tuttol’algoritmo è O(n 2 ), mentre il numero totale di iterazioni è O(nm). Così, il tempo totale perestensioni che non implicano un aumento del prezzo è O(n 2 m).Costruzione della soluzione ammissibileDato il taglio [ S , S]e il vettore di flusso x ottenuto al termine dell’algoritmo, possiamoottenere un massimo flusso applicando un algoritmo che restituisce alla sorgente il flussoin eccesso, che è entrato nella rete ed è stato accumulato su alcuni nodi di S. In particolare,cancelliamo tutti i nodi in S e tutti gli archi che hanno almeno un estremo appartenente aS ; inoltre, per ogni nodo i∈S, con i ≠ s e tale che∑{( i,j)|j∈S}u ij > 0(4.15)introduciamo un arco (i, s) con flusso e capacità∑x is = uis= uij(4.16){( i,j)|j∈S}(se l’arco (i, s) già esiste, cambiamo la sua capacità ed il flusso ai valori sopraelencati). Nellarete risultante che indichiamo con G, ci poniamo il problema di trovare un vettore di flusso x′tale che i corrispondenti eccessi siano zero. Si può vedere che gli eccessi corrispondenti alvettore di flusso x riferito a G sono uguali agli eccessi non negativi e(i) ottenuti alla finedell’algoritmo per tutti gli i ≠ s. Possiamo così applicare l’algoritmo del massimo flussovisto in questo paragrafo con questo vettore di flusso x e vettore dei prezzi p dato da:p ( i)= 0 se i = s, p (i) = “lunghezza di uno shortest direct path da i a s” se i ≠ s.La coppia (x, p) è valida per il grafo G. Si può mostrare allora che ogni iterazionedell’algoritmo terminerà con un’operazione di aumento su un path che parte da un nodo i cone(i) > 0 e termina al nodo sorgente s. Osserviamo che, dato un qualsiasi vettore di flussoammissibile e un nodo i con eccesso positivo, esiste un augmenting path che parte da i etermina su un nodo con eccesso negativo (vedi appendice A.1: decomposizione del flusso).Nel nostro caso il nodo s è il solo nodo con eccesso negativo. In tal modo l’algoritmoterminerà quando gli eccessi di tutti i nodi i ≠ s saranno ridotti a zero, mentre fino al termine67

dell’algoritmo i flussi sugli archi (i, s) saranno uguali al valore iniziale dato dall’equazione(4.16), poiché questi archi non possono far parte di un augmenting path. Se x′ ij è il flussofinale di ogni arco (i, j) di G, si può mostrare, usando anche il fatto che e(i) = 0 per tutti glii ∈ Sx ij * = x′ ij secon i ≠ t, che il vettore di flusso x * , così definito:x ij * = x ij altrimenti,i ∉ S , j ∉ Savrà eccesso e(i) * soddisfacente le condizioni e(i) * = 0 per ogni i ≠ s, t, e(s) * < 0 e e(t) * > 0,finché non verrà saturato il taglio [ S , S]. Così, dal teorema del massimo flusso - minimotaglio, x * deve essere un flusso massimo e [ S , S]deve essere un taglio minimo.Varianti dell’algoritmo Auction max/flowDescriviamo in questa sezione diverse modifiche che possono essere apportateall’algoritmo precedente al fine di incrementarne le prestazioni. L’algoritmo Auction puòcreare un taglio saturo molto velocemente e sprecare ulteriore tempo dopo aver creato taletaglio per incrementare ad n il prezzo dei nodi con eccesso positivo. E’ importante,pertanto, utilizzare delle procedure che individuano velocemente la presenza di tagli saturi.Una possibilità è l’euristica gap, descritta nel capitolo 2; un diverso approccio è costituitodall’eseguire periodicamente una visita in ampiezza a partire dal nodo pozzo, e costruirel’insieme S dei nodi da ognuno dei quali esiste un direct path che termina al nodo pozzo.Se tutti i nodi in S hanno eccesso nullo, allora S definisce un taglio minimo. Notiamo chenel costruire S se viene individuato un nodo con eccesso positivo, la visita in ampiezza puòessere terminata.In una versione alternativa di tale schema, può essere effettuato un global repricing, doveindividuiamo tutti i nodi in S, ovvero tutti i nodi per cui esiste un direct path verso il pozzo,e rietichettiamo il prezzo di ognuno di tali nodi alla lunghezza del più piccolo direct pathdal nodo in considerazione al nodo pozzo. Il prezzo dei nodi che non sono raggiungibilidurante tale processo sarà settato ad n, in modo tale che saranno esclusi automaticamentedal processo di selezione dell’algoritmo. E’ importante associare al global repricingun’euristica che assicura che tale metodo non sia eseguito molto frequentemente, a causadell’associato overhead.68

Nell’algoritmo non è stato specificato il criterio con cui scegliere il nodo con eccessopositivo che sarà il nodo iniziale del path. Una possibilità è scegliere un nodo con il piùgrande prezzo minore di n tra i prezzi dei nodi in N che hanno eccesso positivo.Un’alternativa è mantenere i nodi con eccesso positivo e prezzo minore di n in una codaFIFO, ed estrarre il nodo in testa alla coda.Un ulteriore miglioramento riguarda il flusso spedito lungo l’augmenting path individuato.Anziché spedire la stessa quantità di flusso lungo ogni arco del path, è possibile spedirelungo ogni arco (i, j) il massimo possibile, ovvero min{e(i), r ij }. Tale metodo, chechiameremo aumento greedy, consente di ovviare all’inconveniente degli algoritmiaugmenting path, di cui abbiamo discusso nel paragrafo 3.1.4.4 Algoritmo Auction/BudgetConsideriamo l’algoritmo Auction originale nel momento in cui estrae un nodo coneccesso positivo, diciamo i 1 . Estratto tale nodo, l’algoritmo Auction originale cercherà diidentificare un augmenting path che inizi da tale nodo ed abbia come nodo terminale ilnodo pozzo. Nell’algoritmo Auction/Budget, associamo al path P che l’algoritmo costruiràa partire da i 1 una quantità positiva definita budget( P i1). La quantità budget( P i1)rappresenta una misura del prezzo che si è disposti a pagare per effettuare un’operazionedi aumento sul path P che sarà costruito a partire da i 1 . E’ possibile definire budget( P i1)in funzione di p(i 1 ), ad esempio k p(i 1 ). Una volta estratto il nodo iniziale i 1 , e calcolatobudget( P i1), l’algoritmo cerca di individuare un augmenting path che inizi da i 1 e siadiretto verso il pozzo, senza necessariamente raggiungerlo. Per far ciò, ogni volta chel’algoritmo estende il path su un nodo j decrementa budget( P i1) del valore p(j); quandoinvece l’algoritmo contrae il path eliminando il nodo terminale, esso incrementabudget( P i1) del prezzo del nodo terminale eliminato dal cammino. Quando, nell’estendersisu un nodo l, si ha che budget( P i1) ≤ 0, l’algoritmo aumenta lungo il cammino da i 1 a l.Notiamo come tale tecnica può essere considerata una estensione della logica Auction:noto un path dal nodo estratto i 1 ad un nodo l più vicino al pozzo di quanto lo sia i 1 ,inviamo flusso da i 1 ad l senza insistere nel raggiungere il nodo pozzo. Descriviamo oraformalmente l’algoritmo.69

algorithm Auction/Budget(K)begininitialize;while esiste un nodo i 1 ≠ t tale che e(i 1 ) > 0 e p(i 1 ) < n dobeginseleziona un nodo i 1 ≠ t tale che e(i 1 ) > 0 e p(i 1 ) < n;Budget:=kp(i 1 );P:=(i 1 );i t := i 1 ;while p(i 1 ) < n AND i t ≠ t AND Budget > 0beginif esiste j ∈ Succ(it)I N(it ,x)tale che p(it)≥ p(j)thenExtend(P, j );Budget:=Budget - p (j);elsifN(it ,x) = ∅ thenContract(P);Budget:=Budget + p(it ) ;elsebeginp(it) :=n;Succ(i t ):={ j |p(j) = minp(j) };j ∈N(it,x)Cand(i t )= {( it,j) ∈ A(it,x)| j ∈ Succ(it)}U {( j,it) ∈ A(it,x)| j ∈ Succ(it)};seleziona j∈Succ(n t );p(i t ):= p (j) + 1;if i t = i 1 OR p(pred(i t )) > p (j)thenExtend(P, j );end;end;elsebeginend;Budget:=Budget - p (j);Contract(P);Budget:=Budget + p(it ) ;if i t =t OR Budget ≤ 0 then augment;end;end;70

procedure initialize;beginend;x := 0;∀i ∈N p(i)=”lunghezza di uno shortest direct path da i a t”;x sj := u sj per ogni arco (s, j) ∈ A(s);p(s) := n;procedure augment;beginfor each ( i, j) ∈ Pbeginend;δ = min{ e(i),rij};Invia δ unità di flusso da i a j;end;Calcolo della lunghezza del camminoStabiliamo ora dei limiti alla lunghezza del cammino costruito con la tecnica del budget,supponendo che budget( P i1) = k p(i 1 ), per un generico k di cui discuteremo in seguito.Lemma 4.11. Supponiamo che l’algoritmo associ ad un nodo estratto i 1 la quantitàbudget( P i1) = k p(i 1 ). Se denotiamo con l(P) la lunghezza del path costruito con la tecnicadel budget, allora vale la seguente relazione:⎢2( 2 p(i1)−1)− (1 − 2 p(i1))− 8kp(i1)⎥k ≤ l(P) ≤ ⎢⎥ + 1. (4.17)⎢2⎣⎥⎦Dim. Poiché vale la proprietà p( i)≥ p(j)∀ ( i,j)∈P, il path costruito sarà lungoalmeno k. Infatti il path di lunghezza minima si ottiene quando budget( P i1) diventanegativo nel minor numero si estensioni, il che si verifica quando in ogni estensione viene71

sottratto il massimo possibile, ovvero p(i 1 ). Dunque per rendere budget( P i1) ≤ 0 occorronoalmeno k estensioni.Consideriamo ora il limite superiore. Il cammino di lunghezza massima si ha quandobudget( P i1) diventa negativo nel maggior numero di estensioni, il che si verifica quandol’algoritmo decrementa budget( P i1) del minimo valore possibile. Sia i t il nodo terminaledel cammino e supponiamo che l’algoritmo estenda il cammino sul nodo j. Poichép( it ) ≤ p(j)+ 1, p(j) è almeno p( it)- 1. Pertanto il cammino di lunghezza massima siottiene quando l’algoritmo in corrispondenza delle varie estensioni decrementa budget( P i1)di p( i1)-1, poi p( i1)-2 e così via. Quante estensioni può effettuare l’algoritmo prima chebudget( P i1) diventi negativo, e dunque terminare la costruzione del path? L’algoritmocontinuerà nell’estendersi finché budget( P i1)>0, cioè finché varrà la condizione:k p(i 1 ) > ( p( i1)-1) + ( p( i1)-2) + … +( p( i1)-x). (4.18)Il più grande intero x per cui vale la condizione precedente indica la lunghezza del path percui una successiva estensione causerà un aumento, ovvero violerà la condizione (4.18).Conoscendo x possiamo dunque stabilire il limite superiore che stiamo cercando.Riscrivendo diversamente la (4.18) otteniamo:xk p(i 1 ) > x p(i 1 ) - ∑ l =l ⇔ k p(i1 1 ) > x p(i 1 ) -x( x +1).22Nell’ipotesi che ∆ = ( 1−2 p(i1))− 8kp(i1)≥ 0, la disuguaglianza precedente è soddisfattaper i valori di x tali che:( 2 p(i1)−1)− (1 − 2 p(i1))2 − 8kp(i1)x < e (4.19)2( 2 p(i1)−1)+ (1 − 2 p(i1))2 − 8kp(i1)x > .2Notiamo ora che la disuguaglianza (4.19) è valida nell’istante in cui l’algoritmo estrae ilnodo i 1 , in quanto si ha x = 0. Il funzionamento dell’algoritmo equivale ad incrementare lalunghezza x del cammino fin quando la (4.18) non sarà più valida, e si verificherà unaumento. Per cui, la seconda soluzione non ha senso dal nostro punto di vista. La (4.19)indica la massima lunghezza del path in corrispondenza della quale una successivaestensione causerà un aumento; considerando anche che la lunghezza del path è un valore72

intero, la lunghezza del path, dopo l’estensione che ha causa l’aumento è limitata⎢2( 2 p(i1)−1)− (1 − 2 p(i1))− 8kp(i1)⎥superiormente da ⎢⎥ + 1.⎢2⎣⎥⎦Se invece ∆ < 0 , la disuguaglianza precedente è sempre soddisfatta. In questo caso, che siverifica scegliendo un k opportunamente grande, l’algoritmo eseguirà l’operazione diaumento solo quando il path si estenderà sul pozzo, in quanto budget( P i1) non diventeràmai negativo.A titolo d’esempio, individuiamo il limite superiore alla lunghezza del path nell’ipotesi chevenga estratto un nodo di prezzo 8 e che k sia uguale a 2. Dalla (4.19) essendo x intero,otteniamo x ≤ 2, il che indica che se il cammino è lungo 2, una successiva estensionerenderà il budget negativo o nullo, e occorrerà un’operazione di aumento. Ricordiamoinfatti che la (4.19) indica il più grande valore di x per cui budget( P i1)>0; di conseguenzail limite superiore alla lunghezza del cammino è 3, che si ottiene direttamente dalla (4.16).Preflow-push e augmenting path come casi particolari dell’Auction/BudgetL’algoritmo Auction/Budget può essere considerato una generalizzazione degli approcciaugmenting path e preflow-push, che possono essere ottenuti da un’opportuna scelta dibudget( P i1). Consideriamo innanzitutto l’algoritmo preflow-push e mostriamo come puòessere ottenuto dall’algoritmo Auction/Budget in cui utilizziamo l’aumento greedy.Entrambi gli algoritmi Auction/Budget e preflow-push, iniziano col saturare gli archiuscenti dalla sorgente. Da questo punto in poi, gli algoritmi si differenziano, infattil’algoritmo preflow-push selezionerà nodi attivi ed individuerà archi downhill su cuiinviare flusso, mentre l’algoritmo Auction/Budget dopo aver selezionato un nodo attivo,cercherà di individuare degli augmenting path. Ipotizziamo che il criterio di selezione deinodi attivi sia lo stesso in entrambi gli algoritmi. Per ridurre l’algoritmo Auction/Budget aquello preflow-push, basta definire budget( P i1)=k p(i 1 ), e scegliere k = 0. In questo modo,una volta selezionato i 1 la successiva estensione causerà l’esecuzione della procedura diaumento su un path di lunghezza 1. Per quel che riguarda l’approccio augmenting path,consideriamo l’algoritmo Auction/Budget in cui evitiamo l’aumento greedy. Per far in73

modo che l’algoritmo Auction/Budget esegua l’operazione di aumento solo quando il pathha raggiunto il nodo pozzo, possiamo definire ancora budget( P i1)=k p(i 1 ) e scegliere k inmodo tale che la condizione (4.18) sia sempre verificata. A tal fine, è sufficiente scegliere k22in modo tale che ∆ = ( 1− 2 p(i1))− 8kp(i1)< 0, ovvero k > ( 1− 2 p(i1))/8 p(i1).La scelta migliore di k dipende dal problema in considerazione. Abbiamo infatti trovatosperimentalmente che un determinato valore di k può essere ottimo per un determinato tipodi problema e non buono per un altro. Come si evince dai risultati sperimentali nelsuccessivo capitolo, un buon compromesso è una scelta di k nell’intervallo [3,10].Correttezza e complessitàAssumendo che l’algoritmo Auction/Budget termini, è semplice mostrare che essoindividua un massimo flusso. L’algoritmo termina quando gli eccessi risiedono solo nelnodo sorgente o nel nodo pozzo, il che implica che al termine dell’algoritmo il preflow èun flusso. Poiché p(s) = n, la rete residua non contiene direct path dal nodo sorgente alnodo pozzo, il che, per il teorema 2.1, implica che il flusso è massimo.Dimostriamo ora che l’algoritmo termina, notandoche ogni iterazione per ladeterminazione dell’augmenting path parziale termina. Infatti, alla fine di una iterazione, siha p(i 1 ) ≥ n, il che ad indicare che non esiste nessun augmenting path da i 1 a t, oppure si haun aumento verso il nodo pozzo, o verso un nodo che dista almeno k dal nodo i 1 (per illemma 4.11). Nel primo caso il numero di nodi i con p(i) ≥ n aumenta strettamente,pertanto possono esistere al più n-2 iterazioni di questo tipo. Per mostrare che il numero diaumenti è finito, notiamo che il prezzo di ogni nodo può essere incrementato al più n volte,e poiché i prezzi assumono valori interi non negativi, quando il prezzo di un nodo ecceden-1 tale nodo non verrà più incrementato. Osserviamo che ogni aumento o esauriscel’eccesso di i 1 , oppure satura almeno un arco. Quando un arco di estremi i e j è saturatonella direzione da i a j, si presentano due possibilità: p ( i)= p(j)+ 1, oppure p ( i)= p(j).Nel secondo caso, poiché j ∈ Succ(i)non è possibile che i ∈ Succ( j), significherebbe cheil path parziale è un ciclo . In entrambi i casi si ha che uno degli al più n incrementi dip ( j) deve verificarsi prima che l’arco possa diventare non saturo e poi saturato ancoranella direzione da i a j. Così il numero di saturazioni di un arco è O(n) e il numero totale di74

saturazioni per ogni arco è O(nm), che stabilisce il limite O(nm) sul numero di iterazioni esul numero di aumenti. Da ciò segue che l’algoritmo termina.Per quel che riguarda il tempo d’esecuzione, vale la stessa analisi effettuata nel Teorema4.10 (c), per cui il tempo d’esecuzione dell’algoritmo è O(n 2 m).75