close

Enter

Log in using OpenID

Algoritmi di approssimazione. - Università degli Studi di Padova

embedDownload
Algoritmi di approssimazione.
Livio Colussi
9 dicembre 2014
2
Introduzione
La soluzione di un problema computazionale consiste nel trovare un procedimento
automatico (l’algoritmo) per calcolare dei risultati (l’output) a partire dai dati
del problema (l’input) utilizzando una quantit`a limitata di risorse (tempo calcolo,
spazio di memoria, ecc.).
Per essere pi`u precisi dovremmo far riferimento a qualche particolare nozione
formale di procedimento automatico; normalmente, nei testi di computabilit`a, si
usano le Macchine di Turing. Dovremmo anche parlare non di dati e risultati ma
di rappresentazioni dei dati e dei risultati; infatti ogni nozione formale di procedimento automatico assume che i dati e i risultati siano rappresentati in qualche
modo particolare, ad esempio come sequenze di simboli: cifre decimali o binarie
(bit) o caratteri di un qualche altro alfabeto.
Normalmente si richiede che un algoritmo soddisfi le seguenti tre condizioni:
(1) calcoli esattamente i risultati voluti (2) utilizzi una quantit`a di risorse limitata
e (3) faccia questo per ogni possibile input. Vi sono per`o situazioni in cui non e`
possibile soddisfare tutte e tre queste condizioni.
Un caso in cui non e` possibile calcolare esattamente i risultati voluti e` quando
dati e/o risultati sono oggetti che non ammettono una rappresentazione finita. Ad
esempio i numeri reali non si possono rappresentare
√ in modo finito e quindi non
possiamo calcolare in modo esatto il valore di 2 o di π. E` quindi giocoforza
lavorare con dei valori approssimati che risultino finitamente rappresentabili, ad
esempio quelli rappresentabili in virgola mobile con un certo numero di cifre per
la mantissa ed un certo numero di cifre per l’esponente.
Lo studio di algoritmi di approssimazione sui numeri reali e` talmente importante da costituire un’intera disciplina: il Calcolo Numerico.
Noi ci interesseremo invece di problemi computazionali in cui sia i dati in
ingresso che i risultati sono finitamente rappresentabili. In particolare considereremo problemi di ottimizzazione discreta in cui non solo vogliamo trovare una soluzione che soddisfi tutte le condizioni poste dal problema ma tra di esse vogliamo
trovarne una di ottima rispetto ad un qualche parametro di ottimalit`a.
Problemi di questo tipo sono molto comuni nelle applicazioni informatiche.
Per citarne soltanto alcuni: ”Trovare le pagine web che sono maggiormente correlate ad una particolare parola chiave” che e` alla base di ogni motore di ricerca;
”Trovare la strada pi`u breve tra due punti di una mappa” che e` alla base di ogni
navigatore satellitare; ”Trovare il miglior modo per inviare un pacchetto da un
nodo ad un altro di una rete” che e` alla base di ogni router di rete; ecc.
3
Purtroppo la maggior parte di questi problemi e` NP-difficile e quindi ogni
algoritmo che li risolve richiede un tempo di esecuzione almeno esponenziale
nella dimensione dell’input (a meno che P=NP). Anche la soluzione di problemi
che si risolvono esattamente con algoritmi di complessit`a polinomiale pu`o risultare troppo costosa (un algoritmo di complessit`a Θ(n10 ) non pu`o certo dirsi poco
costoso).
Non e` quindi possibile soddisfare contemporaneamente tutte e tre le condizioni e dovremo pertanto rilasciarne almeno una delle tre.
Talvolta viene rilasciata la condizione (3) e ci si accontenta di un algoritmo
che risolve esattamente il problema computazionale in un tempo ragionevole soltanto per una particolare classe di input. Possiamo dire di aver risolto in modo
soddisfacente il problema soltanto se siamo in grado di specificare esattamente la
classe di input su cui l’algoritmo funziona e se siamo sicuri che l’algoritmo verr`a
usato soltanto con input appartenenti a tale classe. Questo e` normalmente molto
difficile da ottenere.
Un approccio pi`u comune e` rilasciare la condizione (2) e accettare che per
alcuni input l’algoritmo possa richiedere una quantit`a eccessiva di risorse. Per
controllare che l’algoritmo funzioni bene nelle applicazioni pratiche ci si limita
ad eseguirlo su di un insieme opportunamente scelto di input tipici verificando
che su questi input esso fornisca il risultato in un tempo ragionevole. Se funziona bene sugli input tipici possiamo sperare che esso funzioni bene con tutti gli
input che si presenteranno nella pratica. Questo e` l’approccio generalmente usato per risolvere problemi complessi di ricerca operative, intelligenza artificiale,
programmazione con vincoli, ecc. Il problema con questo approccio e` che abbiamo soltanto la speranza ma non la garanzia che l’algoritmo funzioni bene nelle
applicazioni pratiche.
Noi adotteremo un approccio diverso rilasciando la condizione (1). Ci accontenteremo quindi di un algoritmo di approssimazione che per ogni possibile input
sia in grado di calcolare con risorse limitate dei risultati approssimati che non si
discostino troppo dai risultati esatti.
Questo approccio ci consente inoltre di gestire situazioni in cui il problema
richiede di elaborare i dati in tempo reale, ossia i dati vengono forniti all’algoritmo uno alla volta e si richiede che essi vengano elaborati immediatamente senza
conoscere i dati successivi. E` quindi giocoforza calcolare una soluzione che, a
posteriori, conoscendo tutti i dati potrebbe essere migliorata. Un algoritmo di
approssimazione di questo tipo si dice algoritmo on-line.
Vedremo come sia talvolta possibile trovare degli algoritmi di approssimazione che calcolano una soluzione accettabilmente approssimata con un costo spesso
4
molto ma molto inferiore.
In questo corso illustreremo le principali tecniche usate per ottenere algoritmi
di approssimazione. Illustreremo queste tecniche studiando un certo numero di algoritmi di approssimazione proposti nella letteratura specializzata per la soluzione
di certi problemi classici.
Cominceremo con problemi che richiedono il tempo reale illustrando gli algoritmi on-line per i problemi della paginazione e dei k-server.
Vedremo poi alcuni algoritmi di approssimazione per problemi NP-completi o
anche polinomiali ma troppo costosi quali, ad esempio, il problema del commesso
viaggiatore, il problema della copertura di vertici di costo minimo, il problema del
matching di costo minimo e il problema del taglio massimo.
Infine introdurremo il concetto di schemi di approssimazione studiando le soluzioni approssimate per i due problemi dell’impacchettamento e della schedulazione.
Vedremo che talvolta ci sar`a utile usare la randomizzazione la quale spesso
ci permette di ottenere algoritmi di approssimazione molto pi`u semplici ed efficienti e la cui soluzione risulta accettabilmente approssimata con altissima probabilit`a. Ai fini pratici possiamo spesso accettare una minima probabilit`a che
l’approssimazione ottenuta non sia sufficientemente buona.
Capitolo 1
Algoritmi on-line
1.1
Introduzione
Il concetto di algoritmo on-line e` abbastanza vecchio. Esso e` gi`a presente negli
anni settanta, ad esempio, nella letteratura relativa al problema dell’impacchettamento (bin-packing) [28, 36], ma e` diventato una importante area di ricerca
soltanto dopo la pubblicazione del fondamentale articolo di Sleator e Tarjan [35]
nel 1985.
Normalmente, quando risolviamo dei problemi e progettiamo degli algoritmi
noi assumiamo che tutti i dati siano noti a priori. Ma in molte comuni situazioni
questo pu`o non essere vero: invece di conoscere tutti i dati in anticipo essi ci
vengono forniti man mano che procediamo. Vediamo alcuni esempi.
1.1.1
Problema dell’investimento
Consideriamo un investitore avente a disposizione una certa somma che desidera
investire in modo tale da massimizzare il suo guadagno alla fine di un certo periodo di tempo. Egli pu`o scegliere tra varie possibilit`a: pu`o acquistare dei fondi
in valuta nazionale o in valuta estera, pu`o acquistare certificati di deposito oppure investire in azioni. Pu`o tenere un portafoglio misto e pu`o modificarne la
composizione durante tutto il periodo di investimento.
Se l’investitore conoscesse l’andamento dei mercati finanziari per tutto il periodo di tempo potrebbe certamente calcolare la soluzione che rende massimo il
suo guadagno. Purtroppo questa conoscenza la potr`a avere soltanto alla fine quando le sue scelte di investimento le avr`a gia fatte. A quel punto l’investitore pu`o
5
6
CAPITOLO 1. ALGORITMI ON-LINE
soltanto togliersi la soddisfazione di calcolare quanto avrebbe potuto guadagnare
e confrontarlo con il guadagno da lui effettivamente ottenuto. In questo modo egli
pu`o anche valutare la bont`a della strategia on-line usata.
Un algoritmo on-line per il problema dell’investimento e` quindi semplicemente una strategia che ad ogni istante decide la composizione del portafoglio sulla
base soltanto delle informazioni sul passato ma senza avere alcuna conoscenza
del futuro. Il guadagno ottenuto dipende dalla qualit`a della strategia on-line adottata. Vedremo in seguito come si possa quantificare esattamente questa qualit`a
introducendo la nozione di analisi competitiva.
1.1.2
Problema del noleggio degli sci
Consideriamo la seguente situazione: ogni giorno uno sciatore pu`o scegliere di
prendere a noleggio gli sci al costo di 5 euro oppure decidere di acquistare al
costo di T euro un paio di sci che poi utilizzer`a per tutto il resto della stagione.
Sfortunatamente egli non sa quanto duri la stagione sciistica. Se sapesse a priori
che la stagione durer`a n giorni (situazione off-line) la soluzione sarebbe ovvia:
compera gli sci se 5n > T , li prende sempre a noleggio altrimenti. D’altra parte
una strategia on-line per questo problema non pu`o che scegliere un intero k e
quindi noleggiare gli sci per i primi k giorni per poi acquistare gli sci al (k +
1)-esimo giorno se la stagione sciistica dovesse durare pi`u di k giorni.
A questo punto dobbiamo fermarci un momento e chiederci: come possiamo
valutare la bont`a degli algoritmi on-line? Un modo per analizzare un tale algoritmo e` quello di assumere che l’input sia generato casualmente secondo una determinata distribuzione di probabilit`a e calcolare il comportamento atteso rispetto a
tale distribuzione di probabilit`a. Noi vogliamo invece evitare di fare assunzioni
sulla distribuzione di probabilit`a degli input (che e` normalmente molto difficile da
stimare). Lo strumento che svilupperemo non richiede la conoscenza della distribuzione di probabilit`a degli input ma si limita a confrontare il risultato ottenuto
con l’algoritmo on-line con il miglior risultato possibile ottenibile con un algoritmo off-line. Questo tipo di confronto viene detto analisi competitiva ed e` stato
introdotto da Sleator e Tarjan [35].
Definizione 1.1.1 Un algoritmo on-line A e` α-competitivo se per ogni possibile
sequenza ρ di input succede che CA (ρ) ≤ αCO PT (ρ), dove CA (ρ) e` il costo
della strategia on-line A per la sequenza ρ mentre CO PT (ρ) e` il costo, per la
medesima sequenza ρ, di un algoritmo off-line ottimo O PT.
1.2. PROBLEMA DELLA PAGINAZIONE
7
Riconsideriamo l’esempio del noleggio degli sci alla luce della precedente definizione. Una strategia e` quella di acquistare gli sci il primo giorno. Questa
strategia e` (T /5)-competitiva e la sequenza di input peggiore si ha quando la stagione dura un solo giorno, ossia n = 1. Un’altra possibile strategia e` noleggiare
gli sci per i primi T /5 − 1 giorni e comperare gli sci al (T /5)-esimo giorno (se la
stagione dura abbastanza). Se n < T /5 il costo della strategia on-line e di quella
ottima off-line e` lo stesso. Se n ≥ T /5 il costo della strategia on-line e` 2T − 5 e il
costo della strategia off-line ottima e` T . Pertanto questo algoritmo on-line risulta
(2 − 5/T )-competitivo ed e` facile mostrare che esso e` anche il migliore algoritmo
on-line possibile dal punto di vista dell’analisi competitiva.
In alcuni casi la definizione di competitivit`a viene indebolita leggermente richiedendo che CA (ρ) ≤ αCO PT (ρ) + c per una qualche costante c indipendente
da ρ.
1.2
Problema della paginazione
Questo e` un problema che sorge nello sviluppo del software di sistema. Abbiamo
una memoria a due livelli divisa in pagine di lunghezza prefissata. Vi sono k
pagine nella memoria pi`u veloce mentre tutte le rimanenti pagine risiedono nella
memoria pi`u lenta.
La sequenza degli input per il nostro problema e` una sequenza
ρ = r1 , r2 , . . . , rn
di richieste di pagine a cui il programma in esecuzione deve accedere. Quando
viene richiesta una pagina ri se essa si trova nella memoria veloce non dobbiamo fare nulla, altrimenti abbiamo un page-fault e dobbiamo decidere quale pagina in memoria veloce dobbiamo rimpiazzare con la pagina ri richiesta. Il costo
dell’algoritmo di paginazione e` quindi il numero totale di page-fault.
Un algoritmo on-line per questo problema deve decidere la pagina da sostituire
quando avviene un page-fault senza avere nessuna informazione sulle pagine che
verranno richieste in seguito. Ecco alcune possibili strategie on-line:
L IFO (Last-In-First-Out): sostituisci la pagina che e` stata messa nella memoria
veloce per ultima.
F IFO (First-In-First-Out): sostituisci la pagina che e` stata messa nella memoria
veloce per prima.
8
CAPITOLO 1. ALGORITMI ON-LINE
L RU (Least-Recently-Used): sostituisci la pagina usata meno di recente (quella
inutilizzata da pi`u tempo).
L FU (Least-Frequently-Used): sostituisci la pagina che e` stata usata meno volte.
F WF (Flush-When-Full): sostituisci una pagina non marcata qualsiasi e marca
la pagina richiesta. Quando tutte le pagine in memoria veloce risultano
marcate, togli la marcatura a tutte.
Consideriamo la strategia L IFO per il problema della paginazione. Se la sequenza di input e` costituita dalla richiesta alternata di due sole pagine p e q che
all’inizio non stanno in memoria veloce con la strategia L IFO abbiamo un pagefault per ogni pagina mentre una strategia off-line ottima richiede al massimo due
page-fault. Dunque L IFO non e` α-competitiva per nessun α. Diciamo quindi che
L IFO e` non competitiva. Un ragionamento simile mostra che anche L FU e` non
competitiva.
Il seguente teorema mostra che esistono strategie k-competitive (dove k e` la
dimensione della memoria veloce, misurata in pagine). In seguito mostreremo che
questo e` il meglio possibile.
Teorema 1.2.1 (Sleator e Tarjan) L RU e` k-competitivo.
Dimostrazione. Sia B un qualsiasi algoritmo off-line. All’inizio L RU e B hanno
la stessa configurazione nella memoria veloce (ossia partono avendo le stesse k
pagine nella memoria veloce). Dobbiamo dimostrare che, qualunque siano le k
pagine presenti in memoria veloce all’inizio e qualunque sia la sequenza ρ di
pagine richieste abbiamo sempre CL RU (ρ) ≤ kCB (ρ).
Considerando il comportamento di L RU su una sequenza ρ = r1 , r2 , . . . , rn
possiamo suddividerla in fasi f0 , f1 , . . . , f , f +1 nel modo seguente:
ρ = [r1 , . . . , ri0 ], [ri0 +1 , . . . , ri1 ], . . . , [ri −1 +1 , . . . , ri ], [ri
f0
f1
f
+1 , . . . , rn ],
f
+1
dove ogni fase fj termina con un page-fault rij e contiene esattamente k pagefault tranne la prima fase f0 che ne pu`o contenere meno e l’ultima fase f +1 che
non contiene nessun page-fault. La suddivisione si pu`o fare agevolmente partendo
dalla fine della sequenza.
Dimostriamo che il rapporto di competitivit`a k vale per ciascuna fase.
Tale rapporto vale banalmente per f +1 in cui L RU non effettua alcun pagefault. Vale anche per f0 in quanto essa contiene il primo page-fault della sequenza
1.2. PROBLEMA DELLA PAGINAZIONE
9
(che e` anche un page-fault per B visto che i due algoritmi partono con le stesse k
pagine in memoria veloce) e termina con un page-fault ri avendone effettuati un
certo numero h minore o uguale a k.
Consideriamo il costo di una singola fase intermedia fj per L RU e per B. Per
definizione CL RU (fj ) = k. Se dimostriamo che CB (fj ) ≥ 1, ossia che B effettua
almeno un page-fault, abbiamo dimostrato il teorema.
Osserviamo intanto che se L RU effettua due page-fault su due richieste ri e ri
per la stessa pagina p allora, tra le richieste ri+1 , . . . , ri devono essercene almeno
k + 1 relative a pagine distinte. Infatti tra tali richieste ce ne deve essere una rt
per una pagina q (non presente) che sostituisce la pagina p. Subito prima di rt
la memoria veloce conteneva quindi p ed altre k − 1 pagine q1 , . . . , qk−1 diverse
da p ed usate pi`u recentemente di p. Quindi ciascuna delle pagine q1 , . . . , qk−1
deve essere stata richiesta in ri+1 , . . . , rt−1 (vedi Figura 1.1). Siccome q viene
richiesta in rt e p viene richiesta in ri e le pagine q1 , . . . , qk−1 , q, p sono tutte
distinte possiamo concludere che in ri+1 , . . . , ri vengono richieste almeno k + 1
pagine distinte.
p
q1 , . . . , qk−1
ri
p q
rt
p
ri
Figura 1.1: Se p viene scaricata per soddisfare la richiesta rt le altre pagine
q1 , . . . , qk−1 presenti in memoria devono essere state richieste pi`u di recente, ossia
nella zona rossa.
Consideriamo quindi due casi:
Caso 1 nella fase fj l’algoritmo L RU ha un page-fault due volte per la stessa
pagina oppure contiene un page-fault per l’ultima pagina p richiesta nella
fase fj−1 . In questo caso in fj vengono richieste almeno k+1 pagine distinte
(vedi Figura 1.2) e pertanto B deve avere almeno un page-fault in fj .
Caso 2 nella fase fj l’algoritmo L RU ha un page-fault su k pagine distinte e diverse dall’ultima pagina p richiesta nella fase fj−1 . In questo caso all’inizio
della fase fj l’algoritmo B ha in memoria la pagina p e altre k − 1 pagine.
Siccome nella fase vengono richieste k pagine distinte e diverse da p l’algoritmo B deve sostituire almeno una pagina con una nuova pagina e quindi
ha almeno un page-fault nella fase fj .
10
CAPITOLO 1. ALGORITMI ON-LINE
p
fj−1
p
fj
p
fj−1
fj+1
p
fj
fj+1
Figura 1.2: Se in una fase vi e` un page-fault per la richiesta di una pagina p e
questo e` preceduto, nella stessa fase o nell’ultima richiesta della fase precedente,
da un altro page-fault per la stessa pagina p allora devono essere richieste almeno
k + 1 pagine distinte nella zona rossa e quindi all’interno della fase.
Siccome questo vale per ogni algoritmo off-line vale, in particolare, anche per un
algoritmo off-line ottimo O PT e quindi L RU e` k-competitivo.
In modo del tutto analogo si pu`o dimostrare che anche F IFO e` k-competitivo.
La morale di questa tecnica si pu`o riassumere nel seguente modo: possiamo
vedere la competitivit`a come un gioco tra l’algoritmo A ed un avversario B che
cerca di costruire degli input cattivi per A conoscendo a priori la strategia usata
da A. Possiamo cio´e vedere la cosa come un gioco tra un giocatore A ed un
avversario B. L’avversario B fa la prima mossa scegliendo la prima pagina r1 da
richiedere dopo di che il giocatore A deve processare tale richiesta. Quindi B fa
la seconda mossa scegliendo r2 ed A processa r2 , e cos`ı via. Siccome B conosce
la strategia di A esso pu`o simulare il gioco e scegliere ancor prima dell’inizio del
gioco la sequenza di richieste pi`u ostica per A. L’algoritmo B inoltre calcola il
numero di page-fault CA (ρ) effettuato da A e, alla fine, esegue un algoritmo offline ottimo O PT sulla sequenza ρ calcolando CO PT (ρ) e quindi comunica ad A il
rapporto di competitivit`a CA (ρ)/CO PT (ρ) da esso raggiunto.
Un’altra cosa da notare nella dimostrazione del teorema precedente e` che non
abbiamo usato esplicitamente un algoritmo ottimale O PT. Ci siamo limitati a
confrontare il costo dell’algoritmo on-line con un limite inferiore per il costo di
qualsiasi algoritmo off-line. Questa osservazione pu`o sembrare ovvia ma la comparazione con un limite inferiore e` una tecnica abbastanza comune nell’analisi
1.3. ALGORITMO OFF-LINE DI PAGINAZIONE OTTIMO
11
degli algoritmi (non soltanto per gli algoritmi on-line ma anche per gli algoritmi
approssimati che vedremo in seguito).
1.3
Un algoritmo di paginazione off-line ottimo
In questa sezione mostriamo un algoritmo di paginazione off-line ottimo. L’algoritmo che consideriamo e` l’algoritmo L FD (per Longest Forward Distance) che
quando deve rimuovere una pagina per sostituirla con quella richiesta ne sceglie
una che non verr`a pi`u richiesta se ce ne sono, altrimenti sceglie la pagina che
verr`a successivamente richiesta per ultima tra tutte le pagine attualmente presenti
in memoria veloce. Ricordiamo che L FD, essendo un algoritmo off-line, conosce
tutta la sequenza delle richieste comprese quelle che non ha ancora processato.
Teorema 1.3.1 (Belady) L FD e` un algoritmo di paginazione off-line ottimo.
Dimostrazione.
La dimostrazione e` per assurdo. Supponiamo esista un algoritmo off-line
A migliore di L FD e sia ρ = r1 , r2 , . . . , rn una sequenza di pagine tale che
CL FD (ρ) > CA (ρ). Possiamo supporre che A sia ottimo sulla sequenza ρ nel
senso che CB (ρ) ≥ CA (ρ) per ogni altro algoritmo off-line B (altrimenti potremmo modificare A in modo che verifichi preventivamente se il suo input e` ρ e in tal
caso si comporti come B).
Sia L0 = A0 l’insieme iniziale delle pagine in memoria veloce (che e` lo
stesso per i due algoritmi) e siano Li ed Ai gli insiemi di pagine che si trovano in memoria veloce dopo l’elaborazione della richiesta ri da parte di L FD e A
rispettivamente.
Ad un certo punto nell’elaborazione della sequenza ρ i due algoritmi divergono. Sia i il primo indice tale che Li = Ai . Prima di processare ri i due algoritmi
hanno le stesse pagine in memoria veloce per cui ri origina un page-fault per entrambi. Siccome i due algoritmi si comportano diversamente su ri essi scaricano
due pagine diverse per servire ri . Dunque Li ed Ai hanno esattamente k − 1 pagine in comune, ossia |Li ∩ Ai | = k − 1. Inoltre, il costo per processare le prime i
richieste e` lo stesso per i due algoritmi.
Mostreremo come sia possibile modificare l’algoritmo off-line A per ottenere
un altro algoritmo off-line B che diverge da L FD su di una richiesta successiva a
ri e tale che CB (ρ) = CA (ρ).
12
CAPITOLO 1. ALGORITMI ON-LINE
Ripetendo questa operazione arriveremo quindi all’assurdo di un algoritmo
che non diverge mai da L FD sulla sequenza ρ pur avendo un costo su ρ uguale a
CA (ρ), da cui CL FD (ρ) = CB (ρ) = CA (ρ) contro l’ipotesi CL FD (ρ) > CA (ρ).
Sia dunque q la pagina scaricata da L FD per rispondere alla richiesta ri e p
quella scaricata da A. Osserviamo che nelle richieste successive a ri , la pagina
q pu`o essere richiesta soltanto dopo che sia stata richiesta la pagina p (altrimenti
L FD avrebbe scaricato p invece di q).
L’algoritmo B si comporta come A per processare le prime i − 1 richieste e
quindi si comporta come L FD nel processare ri (scarica la pagina q invece della
p). Osserviamo che il numero di page-fault eseguiti da B per processare le prime
i richieste e` lo stesso di A (ossia CB (ρi ) = CA (ρi ) dove ρi = r1 , . . . , ri e` la
sequenza delle prime i richieste di ρ) e che le configurazioni di memoria di B
sono le stesse di L FD per ogni j = 1, . . . , i e di conseguenza |Bi ∩ Ai | = k − 1.
A
B
p
Ai = [q1 , . . . , qk−1 , q]
q r Bi = Li = [q1 , . . . , qk−1 , p]
i
CB (ρi ) = CA (ρi )
Da questo punto in poi l’algoritmo B si comporta in modo che dopo aver
processato le prime j richieste ρj esso si trovi in uno dei seguenti tre casi:
Caso 1 CB (ρj ) = CA (ρj ) e Bj = Aj .
Caso 2 CB (ρj ) = CA (ρj ), Bj = {q1 , . . . , qk−1 , p} e Aj = {q1 , . . . , qk−1 , q}
differiscono per una sola pagina e tra le successive richieste rj+1 , . . . , rn
una eventuale richiesta della pagina q potr`a comparire soltanto dopo che sia
stata richiesta la pagina p.
Caso 3 CB (ρj ) < CA (ρj ), Bj = {q1 , . . . , qk−1 , p} e Aj = {q1 , . . . , qk−1 , q}
differiscono per una sola pagina.
Osserviamo che dopo aver processato la richiesta ri ci si trova nel Caso 2.
Vediamo dunque come l’algoritmo B si comporta quando deve processare una
richiesta rj successiva a ri a seconda del caso in cui si trova dopo aver processato
la richiesta precedente rj−1 .
1.3. ALGORITMO OFF-LINE DI PAGINAZIONE OTTIMO
13
Se dopo aver processato rj−1 l’algoritmo B si trova nel Caso 1 esso si comporta come A rimanendo quindi nel Caso 1 fino alla fine della sequenza ρ per cui
CB (ρ) = CA (ρ).
Se rj non causa un page-fault per nessuno dei due algoritmi non ci sono problemi: si prosegue rimanendo nello stesso caso. Vediamo quindi come procedere
nei casi 2 e 3 quando almeno uno dei due algoritmi ha un page-fault su rj .
Se dopo aver processato rj−1 l’algoritmo B si trova nel Caso 2 abbiamo le
seguenti due possibilit`a a seconda della pagina richiesta da rj (che sappiamo non
poter essere q):
1. rj = s diversa sia da p che da q. In questo caso se A scarica q, B scarica p
e i due algoritmi convergono a Bj = Aj (Caso 1). Se invece A scarica una
pagina comune, ad esempio q1 , anche B scarica la stessa pagina q1 in modo
da rimanere nella stessa situazione precedente (Caso 2).
A
Aj−1 = [q1 , . . . , qk−1 , q]
q s
Aj = [q1 , . . . , qk−1 , s]
B
Bj−1 = [q1 , . . . , qk−1 , p]
pr s
Bj = [q1 , . . . , qk−1 , s]
CB (ρj−1 ) = CA (ρj−1 )
j
CB (ρj ) = CA (ρj )
A
Aj−1 = [q1 , . . . , qk−1 , q]
q1 s
Aj = [s, . . . , qk−1 , q]
B
Bj−1 = [q1 , . . . , qk−1 , p]
q1 r s
Bj = [s, . . . , qk−1 , p]
CB (ρj−1 ) = CA (ρj−1 )
j
CB (ρj ) = CA (ρj )
2. rj = p. In questo caso B non ha page-fault mentre A scarica una pagina.
A non pu`o scaricare q altrimenti avremmo Bj = Aj con costo CB (ρj ) <
CA (ρj ) e dunque B potrebbe continuare come A per processare l’intera
sequenza con costo CB (ρ) < CA (ρ) contro l’ipotesi di minimalit`a di A su
ρ.
Quindi A scarica una pagina comune, diciamo q1 , sostituendola con p. Rimane quindi vero |Bj ∩ Aj | = k − 1 ma non e` pi`u necessariamente vero
che vi sia un ordine obbligato tra le successive richieste delle due pagine
non comuni. In compenso CB (ρj ) risulta strettamente minore di CA (ρj ) e
quindi siamo nel Caso 3.
14
CAPITOLO 1. ALGORITMI ON-LINE
A
Aj−1 = [q1 , . . . , qk−1 , q]
B
Bj−1 = [q1 , . . . , qk−1 , p]
CB (ρj−1 ) = CA (ρj−1 )
q1 p
rj
Aj = [p, q2 , . . . , qk−1 , q]
Bj = [p, q2 , . . . , qk−1 , q1 ]
CB (ρj ) < CA (ρj )
Supponiamo quindi che dopo aver processato rj−1 l’algoritmo B si trovi nel
Caso 3. Abbiamo le seguenti tre possibilit`a:
1. rj = s diversa sia da p che da q. In questo caso A non pu`o scaricare q
altrimenti B potrebbe scaricare p convergendo a A con un costo strettamente
inferiore, contro l’ipotesi di minimalit`a di A su ρ.
Quindi A scarica una pagina comune, diciamo q1 , e B si comporta allo
stesso modo mantenendosi nel Caso 3.
A
Aj−1 = [q1 , . . . , qk−1 , q]
q1 s
Aj = [s, q2 , . . . , qk−1 , q]
B
Bj−1 = [q1 , . . . , qk−1 , p]
q1 r s
Bj = [s, q2 , . . . , qk−1 , p]
CB (ρj−1 ) < CA (ρj−1 )
j
CB (ρj ) < CA (ρj )
2. rj = p. In questo caso B non ha page-fault e A non pu`o scaricare q altrimenti B convergerebbe a A con un costo strettamente inferiore, contro
l’ipotesi di minimalit`a di A su ρ.
Quindi A scarica una pagina comune, diciamo q1 , rimanendo nel Caso 3.
A
Aj−1 = [q1 , . . . , qk−1 , q]
B
Bj−1 = [q1 , . . . , qk−1 , p]
CB (ρj−1 ) < CA (ρj−1 )
q1 p
rj
Aj = [p, q2 , . . . , qk−1 , q]
Bj = [p, q2 , . . . , qk−1 , q1 ]
CB (ρj ) < CA (ρj )
3. rj = q. In questo caso A non ha page-fault e B scarica p per sostituirla
con q. I due algoritmi convergono con costi CB (ρj ) ≤ CA (ρj ). Siccome,
per la minimalit`a di A su ρ, non pu`o essere CB (ρj ) < CA (ρj ) avremo che
CB (ρj ) = CA (ρj ) e quindi siamo nel Caso 1.
1.4. LIMITE INFERIORE PER LA COMPETITIVITA`
A
Aj−1 = [q1 , . . . , qk−1 , q]
B
Bj−1 = [q1 , . . . , qk−1 , p]
CB (ρj−1 ) < CA (ρj−1 )
15
Aj = [q1 , . . . , qk−1 , q]
pr q
j
Bj = [q1 , . . . , qk−1 , q]
CB (ρj ) ≤ CA (ρj )
Alla fine dell’intera sequenza ρ non si pu`o essere nel Caso 3 in quanto A e` ottimo
sulla sequenza ρ. Quindi avremo CB (ρ) = CA (ρ) con B che diverge da L FD su
di una richiesta successiva a ri .
1.4
Limite inferiore per la competitivit`a degli algoritmi di paginazione
In questa sezione mostriamo che k e` un limite inferiore per il rapporto di competitivit`a α di ogni algoritmo deterministico di paginazione on-line, il che ci permette di concludere che L RU e` un algoritmo deterministico on-line ottimo per il
problema della paginazione.
Per la dimostrazione ci serve il seguente:
Lemma 1.4.1 Per ogni sequenza ρ di richieste di pagine scelte in un insieme di
k + 1 pagine distinte l’algoritmo off-line ottimo L FD non pu`o originare page-fault
su due richieste a distanza minore di k.
Dimostrazione. Siano ri e rj due richieste che originano due page-fault consecutivi e dimostriamo che j − i ≥ k.
Siccome abbiamo soltanto k + 1 pagine, abbiamo un page-fault soltanto se la
pagina richiesta e` l’unica pagina non residente in memoria veloce. Sia p la pagina
richiesta in ri e sia q la pagina scaricata. Il prossimo page-fault avviene soltanto
quando viene richiesta q (che e` quindi la pagina richiesta in rj ). Per processare ri
l’algoritmo L FD sceglie la pagina q che verr`a richiesta per ultima tra tutte quelle
presenti in memoria. Di conseguenza ciascuna delle altre k − 1 pagine dovr`a
comparire tra le richiesta ri+1 , . . . , rj−1 e dunque j − i − 1 ≥ k − 1, ovvero
j − i ≥ k.
Possiamo quindi dimostrare il seguente:
16
CAPITOLO 1. ALGORITMI ON-LINE
Teorema 1.4.2 Per ogni algoritmo di paginazione on-line deterministico A esiste
una sequenza ρ di richieste tale che CA (ρ) ≥ kCL FD (ρ).
Dimostrazione. L’avversario di A costruisce una sequenza ρ = r1 , . . . , rk di lunghezza k usando un insieme di k + 1 pagine distinte: ognuna delle richieste della
sequenza richiede l’unica pagina non presente in memoria veloce di A prima della
richiesta stessa. Tranne la prima volta la pagina non presente in memoria e` quella appena scaricata dall’algoritmo per soddisfare la richiesta precedente (e che
l’avversario conosce in quanto conosce la strategia di A).
Chiaramente A effettua k page fault, uno per ogni richiesta mentre, per il
lemma precedente, L FD non pu`o avere pi`u di un page-fault. Quindi CA (ρ) ≥
kCL FD (ρ).
Osserviamo che siccome anche F IFO e` k-competitivo e` anch’esso un algoritmo deterministico on-line ottimo per il problema della paginazione.
1.5
Algoritmi on-line randomizzati
Gli algoritmi on-line di cui abbiamo discusso finora sono deterministici. Un difetto di questi algoritmi e` che l’avversario pu`o sempre determinare esattamente il
loro comportamento su di una sequenza ρ. Questo permette all’avversario di trovare degli input diabolici del tipo di quelli che abbiamo visto nella dimostrazione
del teorema precedente.
Questo motiva l’introduzione della classe degli algoritmi on-line randomizzati
che si comportano meglio da questo punto di vista. Informalmente un algoritmo
on-line randomizzato e` soltanto un algoritmo on-line A che ha a disposizione una
monetina da lanciare. Ogni volta che deve servire una richiesta esso lancia una
o pi`u volte la monetina ed in base all’esito di tali lanci decide come servire la
richiesta.
Per dare una definizione formale di algoritmo on-line randomizzato osserviamo che se fissiamo a priori una sequenza infinita x di risultati dei lanci di monetina
effettuati dall’algoritmo allora l’algoritmo diventa deterministico. Se indichiamo
con 0 e 1 i due possibili esiti di un lancio possiamo interpretare una sequenza di
esiti come una sequenza b1 b2 b3 . . . di cifre binarie.
Questo giustifica la seguente:
Definizione 1.5.1 Un algoritmo on-line randomizzato A e` una famiglia di algoritmi on-line deterministici {Ax : x ∈ {0, 1}∞ }.
1.5. ALGORITMI ON-LINE RANDOMIZZATI
17
Notiamo che, quando parliamo di competitivit`a degli algoritmi on-line randomizzati, dobbiamo decidere quali informazioni sono a disposizione dell’avversario.
Definizione 1.5.2 Un avversario ignaro e` un avversario che conosce gli algoritmi
on-line deterministici {Ax } che costituiscono A, ma non ha accesso alle scelte
casuali di A (e quindi non conosce il particolare algoritmo deterministico Ax
scelto).
La definizione precedente implica, tra l’altro, che l’avversario non conosce
il contenuto della memoria di A. Quindi l’avversario deve poter decidere tutta
la sequenza di richieste prima che il gioco tra lui e l’algoritmo A abbia inizio.
Dunque la randomizzazione permette di nascondere ad un avversario ignaro lo
stato dell’algoritmo on-line. La nozione di competitivit`a per gli algoritmi on-line
randomizzati e` la seguente:
Definizione 1.5.3 Un algoritmo on-line randomizzato A = {Ax : x ∈ {0, 1}∞ }
si dice α-competitivo contro un avversario ignaro se esiste una costante c ≥ 0
tale che per ogni sequenza ρ di richieste:
E[CAx (ρ)] ≤ αCO PT (ρ) + c
(1.1)
dove il valore atteso e` calcolato rispetto alla scelta casuale della sequenza x ∈
{0, 1}∞ .
La costante addizionale c e` introdotta per poter tener conto di eventuali differenze tra le configurazioni iniziali dell’algoritmo e dell’avversario.
Per poter calcolare il valore atteso E[CAx (ρ)] dobbiamo definire la distribuzione di probabilit`a sulle sequenze infinite di esiti dei lanci di monetina, ossia sulle sequenze infinite b1 b2 b3 . . . di cifre binarie. Possiamo interpretare una
sequenza infinita di cifre binarie come la parte frazionaria di un numero reale
x = 0.b1 b2 b3 . . . scritto in base 2. Il numero reale x = 0.b1 b2 b3 . . . e` ovviamente
compreso tra 0 e 1. Viceversa sappiamo che ogni numero reale compreso tra 0 e
1 pu`o essere rappresentato in base 2 in modo essenzialmente unico1 . Possiamo
quindi identificare una sequenza infinita b1 b2 b3 . . . di esiti di lanci di monetine con
un numero reale 0 ≤ x ≤ 1.
1
essenzialmente significa che i numeri che non hanno rappresentazione unica sono un insieme di misura nulla. Infatti i numeri tra 0 e 1 che in base 2 hanno due rappresentazioni distinte
0.b1 . . . bk 10000 . . . e 0.b1 . . . bk 01111 . . . sono soltanto i numeri razionali il cui denominatore e`
potenza di 2.
18
CAPITOLO 1. ALGORITMI ON-LINE
Se ogni cifra binaria bi viene scelta casualmente ed indipendentemente dalle scelte precedenti il numero reale x = 0.b1 b2 b3 . . . e` un numero reale estratto
casualmente dall’intervallo [0, 1] con distribuzione uniforme.
Dunque, ai fini del calcolo del valore atteso, possiamo considerare un algoritmo randomizzato come una famiglia di algoritmi deterministici indicizzata sui
numeri reali dell’intervallo [0, 1]. Scriveremo quindi A = {Ax : x ∈ [0, 1]}.
Definiremo come probabilit`a di una sequenza finita b1 b2 . . . bn la probabilit`a
di tutte le sue estensioni infinite. Le estensioni infinite di b1 b2 . . . bn sono rappresentate dall’intervallo di numeri reali [a, b] con a = 0.b1 b2 . . . bn 000 . . . e
b = 0.b1 b2 . . . bn 111 . . . .
Siccome tale intervallo ha ampiezza b − a = 1/2n e la distribuzione di probabilit`a e` uniforme in [0, 1], la probabilit`a di b1 b2 . . . bn e` pari all’ampiezza dell’intervallo [a, b], ossia 1/2n .
Ricordiamo che il valore atteso Ex∈X (Z(x)) di una variabile casuale continua
Z(x) con densit`a di probabilit`a {p(x) : x ∈ X} e` definito come
E [Z(x)] =
x∈X
p(x)Z(x)dx
x∈X
Nel nostro caso X = [0, 1] e p(x) = 1 per cui
1
E [CAx (ρ)] =
x∈[0,1]
0
CAx (ρ)dx
Se indichiamo con n = n(ρ) il numero massimo di lanci di monetina effettuati
dall’algoritmo per rispondere alla sequenza di richieste ρ allora due algoritmi deterministici Ax ed Ax relativi a sequenze infinite x e x aventi i primi n elementi
uguali si comportano allo stesso modo sulla sequenza di richieste ρ.
Sia B n = {0, 1}n l’insieme delle sequenze finite di cifre binarie di lunghezza
n e per ogni y ∈ B n indichiamo con Ay un qualsiasi algoritmo deterministico
Ax ottenuto estendendo la sequenza finita y ad una sequenza infinita x. Possiamo
riscrivere l’equazione precedente come:
E [CAx (ρ)] =
x∈[0,1]
y∈B n
1
C (ρ) =
2n Ay
y∈B n
CAy (ρ)
2n
dove la sommatoria e` estesa all’insieme B n delle sequenze di cifre binarie di
lunghezza n e 2n e` il numero di tali sequenze.
Vediamo due particolari algoritmi on-line randomizzati:
1.6. ANALISI DELL’ALGORITMO MARKING
19
R ANDOM L’algoritmo R ANDOM serve ogni page-fault scaricando dalla memoria
veloce una pagina scelta casualmente tra tutte quelle presenti.
M ARKING Inizialmente tutte le pagine in memoria veloce sono marcate. Quando
viene richiesta una pagina p:
• Se la pagina p e` in memoria veloce ma non era marcata l’algoritmo la
marca.
• Se la pagina p non e` in memoria veloce l’algoritmo controlla se ci sono
pagine non marcate e in caso contrario toglie la marcatura da tutte le
pagine. Dopo di che scarica una pagina scelta casualmente fra tutte
quelle non marcate e infine carica p e la marca.
Nelle prossime sezioni ci concentreremo sull’algoritmo M ARKING per dimostrare che:
• Mediante la randomizzazione l’algoritmo M ARKING raggiunge un rapporto
di competitivit`a 2Hk contro un avversario ignaro, dove Hk = 1 + 12 + 31 +
. . . + k1 e` il k-esimo numero armonico.
• Il rapporto di competitivit`a di M ARKING e` quasi ottimale nel senso che nessun algoritmo randomizzato ha un rapporto di competitivit`a migliore di Hk .
Per dimostrare questo useremo un metodo generale per dimostrare limiti
inferiori per algoritmi on-line randomizzati contro un avversario ignaro.
Questi due risultati sono dovuti a Fiat, Karp, Luby, McGeoch e Sleator [24].
1.6
Analisi dell’algoritmo M ARKING
Teorema 1.6.1 M ARKING e` 2Hk -competitivo contro qualsiasi avversario ignaro,
dove Hk = 1 + 21 + 13 + . . . + k1 e` il k-esimo numero armonico.
Dimostrazione. Dobbiamo dimostrare che per ogni sequenza ρ di richieste e per
una opportuna costante c indipendente da ρ vale la disuguaglianza
E[CM ARKING (ρ)] ≤ 2Hk CO PT (ρ) + c
(1.2)
dove il valore atteso viene calcolato sulla famiglia {M ARKINGx : x ∈ [0, 1]} degli
algoritmi deterministici che costituiscono M ARKING.
20
CAPITOLO 1. ALGORITMI ON-LINE
L’avversario ignaro non conosce il contenuto iniziale della memoria veloce
dell’algoritmo M ARKING e pertanto nell’analisi dobbiamo tener conto del fatto
che i due algoritmi partono con configurazioni di memoria distinte. D’altra parte
la configurazione iniziale di memoria pu`o contribuire per una differenza di al pi`u
k page-fault.
Possiamo dunque usare la costante c nella disuguaglianza 1.2 per tener conto della differenza dovuta alla configurazione iniziale e assumere quindi che le
configurazioni iniziali siano uguali.
Suddividiamo la sequenza di richieste ρ in fasi f0 , f1 , . . . , ft , ft+1 in corrispondenza dei punti in cui l’algoritmo M ARKING smarca tutte le pagine.
Possiamo suddividere una sequenza di richieste ρ nelle fasi f0 , f1 , . . . , ft , ft+1
nel modo seguente.
Siccome all’inizio le pagine sono tutte marcate, la fase f0 non contiene nessun
page-fault e la fase f1 inizia con il primo page-fault che fa smarcare tutte le pagine.
Anche le fasi successive iniziano con un page-fault che fa smarcare tutte le
pagine ossia con il primo page-fault che avviene dopo che nella fase precedente
siano state marcate tutte le pagine.
Per come si comporta M ARKING, partendo con tutte le pagine non marcate si
arriva ad averle tutte marcate soltanto dopo che siano state richieste, e quindi marcate, esattamente k pagine distinte. Quindi se una fase fi inizia con una richiesta
rj , la fase successiva fi+1 inizia precisamente con la prima richiesta rj successiva
ad rj tale che in rj , . . . , rj vengano richieste esattamente k + 1 pagine distinte
ossia rj e` la (k + 1)-esima pagina distinta richiesta a partire dall’inizio della fase
fi .
Quindi ognuna delle fasi intermedie f1 , . . . , ft richiede esattamente k pagine
distinte e l’ultima ft+1 richiede al pi`u k pagine distinte.
Le richieste della prima fase f0 non provocano page-fault mentre le richieste
dell’ultima fase ft+1 provocano al pi`u k page-fault che possono essere conteggiati
nella costante c della disuguaglianza 1.2.
Possiamo quindi limitarci a considerare i costi delle fasi intermedie f1 , . . . , ft .
Prima di continuare cerchiamo di chiarire il comportamento di M ARKING su
di una fase mediante le seguenti osservazioni.
Osservazione 1 Quando una pagina viene richiesta in una fase essa viene marcata
e rimane in memoria veloce fino alla fine della fase. Quindi paghiamo un costo 1
per la richiesta di una pagina soltanto se e` la prima volta che essa viene richiesta
nella fase e se essa non e` gi`a in memoria.
1.6. ANALISI DELL’ALGORITMO MARKING
21
Osservazione 2 Alla fine di ogni fase la memoria contiene esattamente le k pagine distinte richieste nella fase ed esse sono tutte marcate.
La cosa si dimostra facilmente per induzione. Quando inizia la prima fase in
memoria ci sono le k pagine iniziali che sono tutte marcate (poich´e nessun pagefault e` ancora avvenuto). La prima fase inizia con un page-fault che provoca la
smarcatura di tutte le pagine preesistenti, dopo di che le k pagine richieste durante
la fase verranno marcate e rimarranno in memoria fino alla fine della fase. Supposto quindi la cosa vera per la fase i-esima, la fase (i + 1)-esima deve iniziare con
un page-fault in quanto la prima pagina richiesta nella fase successiva e` diversa
dalle k pagine richieste nella fase i-esima e che risiedono in memoria alla fine di
tale fase. Dunque la fase (i + 1)-esima inizia con un page-fault che provoca la
smarcatura di tutte le pagine preesistenti, dopo di che le k pagine richieste durante
la fase verranno marcate e rimarranno in memoria fino alla fine della fase.
Osservazione 3 La suddivisione di ρ in fasi non dipende dalle scelte casuali dell’algoritmo M ARKING ma dipende soltanto dalla configurazione iniziale della
memoria e dalla sequenza ρ stessa.
In altre parole, data la configurazione iniziale, la sequenza ρ viene divisa in
fasi nello stesso modo qualunque siano le scelte casuali di M ARKING. Inoltre, per
l’osservazione precedente, neppure l’insieme Mi di pagine presente in memoria
all’inizio di una fase fi dipende dalle scelte casuali di M ARKING: infatti M1 e`
l’insieme di pagine presenti in memoria nella configurazione iniziale mentre per
le fasi successive Mi e` semplicemente l’insieme delle pagine distinte richieste
nella fase precedente fi−1 .
Sia Mi l’insieme di pagine presenti in memoria all’inizio della fase fi ed Mi+1
l’insieme delle pagine presenti in memoria alla fine della fase fi e quindi all’inizio
della fase successiva fi+1 . Chiamiamo pagine stabili le pagine che sono presenti
sia in Mi che in Mi+1 , pagine vecchie quelle presenti in Mi ma non in Mi+1 e
pagine nuove quelle presenti in Mi+1 ma non in Mi .
Per l’osservazione 1, nel calcolare il costo di una fase possiamo limitarci a
considerare soltanto la prima richiesta di ciascuna delle k pagine distinte richieste
nella fase. Per l’osservazione 2, le k pagine distinte richieste durante la fase sono
le pagine stabili e le pagine nuove.
Quando viene richiesta per la prima volta una pagina nuova essa provoca un
page-fault e quindi la prima richiesta di una pagina nuova costa 1.
22
CAPITOLO 1. ALGORITMI ON-LINE
Sfortunatamente non e` certo che le pagine stabili siano ancora in memoria al
momento in cui vengono richieste per la prima volta, possono essere state scaricate precedentemente per far posto ad un’altra pagina. Se la pagina e` ancora in
memoria il costo e` 0 altrimenti il costo e` 1. Quindi il nostro problema principale
e` determinare il costo atteso della prima richiesta di ciascuna pagina stabile.
1.6.1
Il costo atteso della prima richiesta di una pagina stabile
Sia r la prima richiesta di una pagina stabile p durante la fase fi . Supponiamo
che prima di r nella fase siano state richieste n pagine nuove ed s pagine stabili.
Per poter calcolare il costo atteso di r ci serve la probabilit`a che la pagina p sia
ancora in memoria dopo le richieste delle n pagine nuove e delle s pagine stabili.
Osserviamo che siccome r e` la prima richiesta della pagina p se p e` in memoria
essa non e` marcata.
Che cosa sappiamo? Per definizione di pagina stabile sappiamo che le s pagine
stabili erano in Mi . Inoltre, siccome le pagine richieste vengono marcate, le s
pagine stabili richieste prima di p rimangono in memoria fino alla fine della fase e
quindi quando p viene richiesta esse sono in memoria e marcate. Dunque, quando
viene richiesta p le n pagine nuove richieste sono andate a rimpiazzare n delle
altre k − s pagine presenti in memoria all’inizio della fase (vedi Figura 1.3).
pagine stabili
stabili marcate
stabili non marcate
pagine stabili
pagine vecchie
pagine nuove pagine vecchie
pagine nuove
Figura 1.3: Contenuto della memoria all’inizio di una fase, alla prima richiesta di
una pagina stabile ed alla fine della fase.
Siccome le pagine da scaricare vengono scelte casualmente, ognuna delle k−s
pagine presenti in memoria all’inizio della fase e diverse dalle s pagine stabili
richieste prima di p ha la stessa probabilit`a n/(k − s) di essere stata rimossa.
Siccome la pagina p e` una di tali k − s pagine la probabilit`a che la sua richiesta
provochi un page-fault e` n/(k − s) e pertanto il suo costo atteso e` :
n
k−s−n
n
+0·
=
k−s
k−s
k−s
Possiamo sintetizzare questo risultato nel seguente:
E[CM ARKING (r)] = 1 ·
1.6. ANALISI DELL’ALGORITMO MARKING
23
Lemma 1.6.2 Il costo atteso della richiesta della (s + 1)-esima pagina stabile
e` n/(k − s) dove n e` il numero di pagine nuove richieste precedentemente nella
fase.
1.6.2
Limite superiore per il costo di M ARKING su una fase
Vogliamo dimostrare che il costo atteso di M ARKING su di una fase soddisfa la
diseguaglianza
E[CM ARKING (fi )] ≤ ni Hk
dove ni e` il numero totale di pagine nuove richieste nella fase.
Se ni = 0 la cosa e` ovvia: E[CM ARKING (fi )] = 0 = 0Hk . Supponiamo
quindi che nella fase fi vengano richieste ni ≥ 1 pagine nuove.
Ricordiamo che, per l’Osservazione 3, il numero ni non dipende dalle scelte
casuali dell’algoritmo ma soltanto dalla sequenza di richieste. Debbono esserci
quindi esattamente k − ni prime richieste di una pagina stabile durante la fase.
Chiaramente il numero n di pagine nuove richieste prima della richiesta di una
pagina stabile e` minore o uguale ad ni . Usando questo fatto ed il Lemma 1.6.2
possiamo maggiorare la somma dei costi attesi delle k − ni pagine stabili con:
ni
ni
ni
+
+ ... +
k
k−1
k − (k − ni − 1)
1
1
1
= ni
+
+ ... +
k k−1
ni + 1
1
1
1
+
+ ... +
≤ ni
k k−1
2
E[CM ARKING (stabili)] ≤
Siccome ogni pagina nuova costa 1, il costo delle ni pagine nuove e` ni e quindi il
costo atteso dell’intera fase risulta limitato superiormente da
E[CM ARKING (fi )] = E[CM ARKING (stabili)] + ni
1
1
1
≤ ni
+
+ . . . + + 1 = ni Hk
k k−1
2
Vale quindi il seguente:
Lemma 1.6.3 Il costo atteso di M ARKING in una fase intermedia fi e` limitato
superiormente da ni Hk dove Hk = 1 + 12 + . . . + k1 e` il k-esimo numero armonico.
24
1.6.3
CAPITOLO 1. ALGORITMI ON-LINE
Limite inferiore per algoritmi off-line su una fase
Sia A un qualsiasi algoritmo off-line e confrontiamo A con M ARKING sulla stessa
sequenza ρ. Immaginiamo la sequenza ρ suddivisa in fasi come abbiamo fatto
precedentemente e confrontiamo i due algoritmi su di una fase. Sia di il numero
di pagine che all’inizio della fase i-esima stanno nella memoria di A ma non nella
memoria di M ARKING. Notiamo che di dipende soltanto dal comportamento di
A e dalla sequenza ρ ma non dalle scelte casuali di M ARKING in quanto, per
l’Osservazione 3, le pagine in memoria di M ARKING all’inizio di una fase sono
esattamente le pagine richieste nella fase precedente (quelle iniziali per la prima
fase).
Sia ni il numero di pagine nuove richieste all’algoritmo M ARKING durante
la fase fi . Per definizione queste ni pagine non stanno in memoria di M ARKING
all’inizio della fase e quindi almeno ni −di di tali pagine non stanno nella memoria
di A all’inizio della fase. Dunque la fase fi ha un costo CA (fi ) di almeno ni − di
page-fault. Quindi:
CA (fi ) ≥ ni − di
(1.3)
Alla fine della fase fi l’algoritmo A ha in memoria di+1 pagine che non stanno
nella memoria di M ARKING. Siccome alla fine della fase M ARKING ha in memoria esattamente tutte le pagine richieste nella fase, le di+1 pagine che non stanno in
memoria di A devono essere state prima caricate in memoria da A e poi scaricate.
Quindi la fase fi costa almeno di+1 page-fault. Quindi:
CA (fi ) ≥ di+1
(1.4)
Sommando membro a membro le due diseguaglianze 1.3 e 1.4 otteniamo il
seguente limite inferiore per CA (fi )
2CA (fi ) ≥ ni − di + di+1
(1.5)
e sommando su tutte le fasi complete f1 , . . . , ft
t
2CA (f1 , . . . , ft ) ≥
t
(ni − di + di+1 ) = dt+1 − d1 +
i=1
ni
i=1
Siccome d1 = 0 (la configurazione iniziale e` la stessa) e dt+1 ≥ 0 possiamo
concludere che:
t
2CA (f1 , . . . , ft ) ≥
ni
i=1
(1.6)
1.7. UN LIMITE INFERIORE PER ALGORITMI RANDOMIZZATI
1.6.4
25
Il rapporto di competitivit`a di M ARKING
Per il Lemma 1.6.3 il costo atteso E[CM ARKING (f1 , . . . , ft )] per le fasi intermedie e`
t
E[CM ARKING (f1 , . . . , ft ) ≤ Hk
ni
(1.7)
i=1
Mettendo assieme la 1.6 con la 1.7 otteniamo la
E[CM ARKING (f1 , . . . , ft ) ≤ 2Hk CA (f1 , . . . , ft )
(1.8)
e, siccome A e` un algoritmo off-line qualsiasi, questo vale anche per A = O PT e
dunque M ARKING e` 2Hk -competitivo.
1.7
1.7.1
Un limite inferiore per algoritmi randomizzati
Un’utile tecnica
Come possiamo trovare un limite inferiore per il rapporto di competitivit`a α di un
algoritmo randomizzato contro un avversario ignaro?
Possiamo farlo scegliendo arbitrariamente una distribuzione di probabilit`a per
le sequenze ρ in input e valutando il costo atteso del miglior algoritmo on-line
(deterministico) ed il costo atteso del miglior algoritmo off-line O PT rispetto alla
distribuzione di probabilit`a scelta. Illustriamo questo metodo.
Abbiamo visto che un algoritmo randomizzato A pu`o essere definito come
una famiglia {Ax : x ∈ [0, 1]} di algoritmi on-line deterministici. Quindi, quando
diciamo che A e` α-competitivo contro un avversario ignaro intendiamo che per
ogni input ρ vale la diseguaglianza
E [CAx (ρ)] ≤ α CO PT (ρ) + c
x∈[0,1]
dove c e` una costante introdotta per tener conto della differenza nei contenuti iniziali della memoria veloce. Questo ci permette di assumere che O PT e A partano
con le stesse pagine nella memoria veloce.
Siccome questa diseguaglianza e` vera per ogni ρ essa deve essere vera anche
se consideriamo i valori attesi rispetto ad una arbitraria distribuzione di probabilit`a
p(ρ) su di un insieme qualsiasi di sequenze. In particolare, se prendiamo l’insieme
26
CAPITOLO 1. ALGORITMI ON-LINE
Rm di tutte le sequenze di richieste ρ di lunghezza |ρ| = m con una arbitraria
distribuzione di probabilit`a p(ρ) otteniamo
E [ E [CAx (ρ)]] ≤ α Em [CO PT (ρ)] + c
ρ∈R
ρ∈Rm x∈[0,1]
Se CO PT (ρ) = 0 la sequenza ρ contiene soltanto richieste per le k pagine
presenti nella configurazione iniziale di memoria e quindi anche CAx (ρ) = 0 per
ogni x e la disuguaglianza e` soddisfatta per ogni valore di α.
Consideriamo quindi soltanto sequenze ρ tali che CO PT (ρ) = 0 e quindi anche
Eρ∈Rm [CO PT (ρ)] = 0.
Possiamo trovare un limite inferiore esplicitando la diseguaglianza rispetto ad
α ottenendo
Eρ∈Rm [Ex∈[0,1] [CAx (ρ)]] − c
α≥
Eρ∈Rm [CO PT (ρ)]
Sia n = n(m) il numero massimo di lanci di monetina necessari a processare una
sequenza ρ ∈ Rm e sia B n = {0, 1}n l’insieme delle sequenze di cifre binarie
di lunghezza n. Discretizzando il calcolo del valore atteso sulle sequenze finite
y ∈ B n si ottiene:
α≥
Eρ∈Rm [ 21n
y∈B n
CAy (ρ)] − c
Eρ∈Rm [CO PT (ρ)]
e quindi, per la linearit`a del valore atteso
α≥
1
2n
Eρ∈Rm [CAy (ρ)] − c
Eρ∈Rm [CO PT (ρ)]
y∈B n
Se Ay∗ e` quello tra gli algoritmi deterministici {Ay : y ∈ B n } che rende
minimo il valore atteso Eρ∈Rm [CAy (ρ)] allora a maggior ragione abbiamo
α≥
Eρ∈Rm [CAy∗ (ρ)]
Eρ∈Rm [CO PT (ρ)]
−
c
Eρ∈Rm [CO PT (ρ)]
In particolare, se la distribuzione di probabilit`a p(ρ) scelta e` tale per cui2
lim
E [CO PT (ρ)] = ∞
m→∞ ρ∈Rm
2
Una tale distribuzione esiste sempre: ad esempio una distribuzione in cui p(ρ) = 0 soltanto
per le sequenze che richiedono a turno k + 1 pagine distinte. In realt`a Eρ∈Rm [CO PT (ρ)] pu`o non
tendere a ∞ soltanto per distribuzioni di probabilit`a p(ρ) molto particolari.
1.7. UN LIMITE INFERIORE PER ALGORITMI RANDOMIZZATI
27
allora
α ≥ m→∞
lim
Eρ∈Rm [CAy∗ (ρ)]
Eρ∈Rm [CO PT (ρ)]
ossia, per stringhe sufficientemente lunghe il rapporto di competitivit`a di un algoritmo randomizzato contro un avversario ignaro e` almeno grande quanto il rapporto tra il costo atteso del miglior algoritmo deterministico on-line ed il costo atteso
del miglior algoritmo deterministico off-line.
Notiamo che, al fine di determinare un limite inferiore di α, siamo liberi di
scegliere una distribuzione di probabilit`a p(ρ) che massimizza tale rapporto con
l’unico vincolo che limm→∞ Eρ∈Rm [CO PT (ρ)] = ∞.
1.7.2
Applicazione della tecnica al problema della paginazione
Usando il metodo generale dimostreremo il seguente risultato:
Teorema 1.7.1 Per il problema della paginazione, se A e` un algoritmo on-line
randomizzato α-competitivo contro un avversario ignaro allora α ≥ Hk .
Dimostrazione. Per il problema della paginazione sappiamo che L FD e` un algoritmo off-line ottimo. Calcoliamo quindi il limite inferiore
α ≥ m→∞
lim
Eρ∈Rm [CAy∗ (ρ)]
Eρ∈Rm [CL FD (ρ)]
nel modo seguente: scegliamo un insieme Γ di k + 1 pagine distinte e attribuiamo
uguale probabilit`a a tutte le sequenze ρ ∈ Γm ⊆ Rm costituite soltanto da richieste
di pagine in Γ e probabilit`a 0 a tutte le altre sequenze.
Quando un qualsiasi algoritmo on-line si trova a rispondere ad una generica
richiesta ri la pagina richiesta e` , con uguale probabilit`a, una delle k + 1 pagine
dell’insieme Γ. Siccome k di tali pagine stanno in memoria, la probabilit`a di un
page fault e` 1/(k + 1) e quindi, per ogni algoritmo on-line, il costo atteso per
servire ri e` 1/(k + 1) ed il costo atteso per servire tutta la sequenza ρ ∈ Rm e`
Eρ∈Rm [CAy∗ (ρ)] = m/(k + 1).
Abbiamo quindi il limite inferiore
m/(k + 1)
m→∞ E
ρ∈Rm [C L FD (ρ)]
α ≥ lim
28
CAPITOLO 1. ALGORITMI ON-LINE
Se dimostriamo che
lim
m→∞
m
(k + 1) Eρ∈Rm [CL FD (ρ)]
= Hk
(1.9)
possiamo concludere che α ≥ Hk e quindi il teorema e` dimostrato.
Per dimostrare il limite 1.9 dobbiamo studiare il comportamento di L FD sulle
sequenze ρ ∈ Γm che richiedono soltanto pagine nell’insieme prescelto Γ di k + 1
pagine. Per come abbiamo scelto la distribuzione di probabilit`a, tali sequenze
hanno tutte la stessa probabilit`a.
Dividiamo ρ in fasi stocastiche nel modo seguente: la fase i-esima e` costituita
dalle richieste di indici ji , ji + 1, . . . , ji+1 − 1 dove ji e` l’indice della richiesta con
cui inizia la fase i-esima (in particolare j1 = 1 e` l’indice della prima richiesta r1
con cui inizia la prima fase) e la fase (i + 1)-esima inizia con la richiesta di indice
ji+1 , il primo indice successivo a ji tale che in rji , . . . , rji+1 vengano richieste tutte
le k + 1 pagine distinte dell’insieme prescelto.
Notiamo che le ji sono delle variabili casuali in quanto ρ ∈ Γm e` scelta casualmente. Una fase richiede soltanto k pagine distinte e dunque se L FD effettua
un page-fault in una fase, il prossimo page-fault non pu`o avvenire prima della fase
successiva. Quindi il costo di L FD per servire ρ e` minore o uguale al numero di
fasi in cui e` suddivisa ρ. Pertanto, il costo atteso di L FD su ρ ∈ Rm rispetto alla
distribuzione di probabilit`a p(ρ) e` al pi`u pari al numero atteso di fasi in cui sono
suddivise le sequenze ρ ∈ Γm . Quindi
E [CL FD (ρ)] ≤ Em [numero fasi]
ρ∈Γ
ρ∈Rm
Siccome le variabili casuali Yi = ji+1 − ji , che rappresentano la lunghezza
delle fasi, sono indipendenti ed hanno uguale distribuzione, esse costituiscono un
processo di arrivi detto anche di Poisson e pertanto per una elementare propriet`a
dei processi di Poisson
lim
m→∞
m
= E[lunghezza di una fase]
Eρ∈Γm [numero fasi]
= E[j2 − j1 ] = E[j2 ] − 1
Intuitivamente questo dice che il numero atteso di fasi e` asintoticamente uguale
alla lunghezza della sequenza diviso la lunghezza attesa di una fase.
Abbiamo dunque dimostrato che
α≥
E[j2 ] − 1
k+1
1.7. UN LIMITE INFERIORE PER ALGORITMI RANDOMIZZATI
29
Ci resta ora soltanto da calcolare E[j2 ]. Per definizione
j2 = min{t : |{r1 , . . . , rt }| = k + 1}
Ogni ri e` uniformemente distribuito tra le k + 1 pagine dell’insieme Γ prescelto
ed e` indipendente da rj per ogni j = i. Il calcolo di E[j2 ] in questa situazione e`
noto come il problema del raccoglitore di figurine: Data una collezione di k + 1
figurine distinte, E[j2 ] rappresenta il numero atteso di figurine che un collezionista
deve acquistare prima di ottenere la serie completa di figurine, nell’ipotesi che ad
ogni acquisto tutte le figurine siano ugualmente probabili e che il risultato di un
acquisto sia indipendente da quello degli altri acquisti.
Per risolvere questo problema introduciamo le variabili casuali Zt per 1 ≤ t ≤
k + 1 ponendo
Zt = min{i : |{r1 , . . . , ri }| = t}
per cui in particolare Z1 = 1 e Zk+1 = j2 .
Tra Zt e Zt+1 la probabilit`a p di ottenere una nuova pagina e` sempre la stessa
p=
k+1−t
k+1
ad ogni passo.
Possiamo dimostrare che il valore atteso della variabile casuale Y = Zt+1 −Zt
(il numero di figurine da acquistare tra Zt e Zt+1 ) e` l’inverso dalla probabilit`a,
ossia
1
k+1
E[Y ] = =
p
k+1−t
La dimostrazione e` la seguente: Y = 1 con probabilit`a p mentre Y > 1 con
probabilit`a 1 − p. Siccome la probabilit`a di estrarre una nuova pagina e` la stessa
ad ogni passo, il valore atteso del tempo da aspettare per una nuova pagina dopo
aver effettuata una estrazione senza successo rimane sempre lo stesso3 .
Dunque E[Y ] = p · 1 + (1 − p)(1 + E[Y ]) che risolta rispetto ad E[Y ] fornisce
E[Y ] = 1/p.
Quindi
E[j2 ] = E[Zk+1 ]
k
(E[Zt+1 ] − E[Zt ])
= E[Z1 ] +
t=1
3
come non sanno quelli che continuano a scommettere al lotto sui numeri ritardatari.
30
CAPITOLO 1. ALGORITMI ON-LINE
k
(E[Zt+1 − Zt ])
= 1+
t=1
k
= 1+
k+1
t=1 k + 1 − t
k
= 1 + (k + 1)
1
j=1 j
= 1 + (k + 1)Hk
e quindi
1 + (k + 1)Hk − 1
= Hk
k+1
e questo completa la dimostrazione del teorema.
α≥
Dal teorema precedente possiamo desumere che M ARKING e` ottimale a meno di un fattore 2. McGeoch e Sleator in [33] danno un algoritmo on-line randomizzato ottimo (ossia con rapporto di competitivit`a uguale ad Hk ) contro un
avversario ignaro.
1.8
Tipi di avversari
In questa sezione vedremo altri tipi di avversari per gli algoritmi on-line e discuteremo della loro potenza relativa. Le definizioni ed i risultati sono dovuti a
Ben-David, Borodin, Karp, Tardos e Wigderson [18].
Finora abbiamo analizzato il comportamento di un algoritmo on-line randomizzato A contro un avversario ignaro B. B conosce la distribuzione di probabilit`a
degli algoritmi deterministici che costituiscono A ma deve generare una sequenza
ρ di richieste senza conoscere a priori i risultati delle scelte casuali di A e neppure
le pagine presenti in memoria di A all’inizio (in altre parole senza conoscere l’algoritmo deterministico Ax scelto da A). Abbiamo analizzato il comportamento
di A pensandolo come un gioco tra A e B. All’inizio del gioco B sceglie la lunghezza n della sequenza di richieste ρ = r1 , . . . , rn da sottoporre all’algoritmo A
dopo di che B comincia a fare le richieste e A comincia a processare tali richieste
fornendo le risposte a1 , . . . , an . Se A e` randomizzato esso effettua dei lanci di monetina per scegliere la risposta ai da fornire. Per`o B deve fare ciascuna richiesta ri
senza conoscere le risposte a1 , . . . , ai−1 precedentemente fornite dall’algoritmo.
Il gioco non e` interattivo e quindi e` poco interessante — B pu`o scegliere tutte le
1.8. TIPI DI AVVERSARI
31
richieste da fare prima che inizi il gioco. Per rendere il gioco effettivamente interattivo dobbiamo considerare avversari pi`u forti che abbiano accesso in qualche
modo ai risultati dei lanci di monetina dell’algoritmo.
Definizione 1.8.1 Un avversario adattivo B contro un algoritmo randomizzato A
e` un avversario che ha accesso alle scelte casuali precedentemente effettuate da
A. Ossia, quando B sceglie la richiesta ri esso conosce le risposte a1 , . . . , ai−1
fornite da A fino a quel momento.
Nel gioco tra A e B l’avversario non solo deve scegliere la sequenza di richieste per massimizzare il costo CA (B) pagato da A per rispondere alle richieste
fattegli da B ma deve anche mostrare che esso e` in grado di fare meglio. Per
questa ragione anche B deve processare la stessa sequenza di richieste avendo
a disposizione le stesse risorse ed a partire dalla stessa situazione iniziale di A.
Quindi anche B deve sostenere un costo CB (A) per processare a modo suo la
sequenza di richieste che esso stesso ha sottoposto ad A.
Distinguiamo tra due diversi tipi di avversari adattivi in dipendenza del modo
in cui essi processano la sequenza di richieste.
Definizione 1.8.2 Un avversario adattivo off-line B contro un algoritmo A e` un
avversario che genera una richiesta e quindi riceve la risposta di A prima di
formulare la richiesta successiva. Soltanto dopo che A abbia risposto a tutta
la sequenza di domande l’algoritmo B processa la stessa sequenza di richieste
usando la strategia off-line ottima O PT. Quindi CB (A) = CO PT (ρ) dove ρ e` la
sequenza di richieste generata da B.
Definizione 1.8.3 Un avversario adattivo on-line B contro un algoritmo A e` un
avversario che processa la sequenza di richieste contemporaneamente all’algoritmo A. L’avversario B apprende la risposta ai di A ad ogni richiesta ri soltanto
dopo che esso stesso abbia calcolato la sua risposta bi alla richiesta ri ma prima
di formulare la richiesta successiva ri+1 .
Nota 1 O PT e` certamente migliore di ogni algoritmo on-line e quindi per ogni
avversario adattivo on-line esiste un avversario adattivo off-line che funziona almeno altrettanto bene. Quindi il concetto di avversario adattivo off-line e` pi`u forte
di quello di avversario adattivo on-line.
Nota 2 Il concetto di avversario adattivo on-line e` pi`u forte di quello di avversario
ignaro.
32
CAPITOLO 1. ALGORITMI ON-LINE
Consideriamo il caso in cui A e` un algoritmo randomizzato. In questo caso
le risposte a1 , . . . , an sono variabili casuali determinate dai lanci di monetina di
A, ossia dal particolare algoritmo deterministico Ax , con x ∈ [0, 1] scelto da
A. Siccome le risposte b1 , . . . , bn calcolate da B dipendono dalle risposte di A
anch’esse sono delle variabili casuali e dunque anche B si comporta come un
algoritmo randomizzato composto dalla famiglia di algoritmi deterministici {B x :
x ∈ [0, 1]} dove x e` la sequenza di scelte casuali effettuate da A. Anche i costi
associati alle risposte a1 , . . . , an e b1 , . . . , bn sono quindi delle variabili casuali.
Dunque CA (B) e CB (A) sono variabili casuali in quanto ottenute sommando
rispettivamente i costi delle risposte ai e delle risposte bi .
Per valutare l’efficacia di A contro l’avversario B dobbiamo quindi considerare i valori attesi Ex∈[0,1] [CAx (B x )] ed Ex∈[0,1] [CB x (Ax )] di questi costi.
Definizione 1.8.4 Un algoritmo randomizzato A si dice α-competitivo contro un
avversario adattivo B se
E [CAx (B x )] ≤ α E [CB x (Ax )]
x∈[0,1]
x∈[0,1]
Nota 3 Se A e` deterministico non ci sono differenze tra avversari ignaro, adattivi
on-line ed adattivi off-line.
1.9
Competitivit`a contro i vari tipi di avversari
Un avversario adattivo off-line e` talmente forte che un algoritmo on-line che lo
affronta non pu`o trarre alcun beneficio dalla randomizzazione.
Teorema 1.9.1 Se esiste un algoritmo on-line randomizzato A che sia α-competitivo contro ogni avversario adattivo off-line allora esiste anche un algoritmo G
on-line deterministico α-competitivo.
Dimostrazione. Consideriamo le richieste-risposte tra l’avversario B e l’algoritmo A come un gioco tra due persone Bruno e Aldo: Bruno pone le domande e
Aldo risponde.
Una posizione di gioco e` una coppia di sequenze (ρk , αk ) dove ρk = r1 , . . . , rk
sono le richieste fatte da Bruno fino a quel momento e αk = a1 , . . . , ak sono le
risposte date da Aldo.
Una posizione (ρk , αk ) e` immediatamente vincente per Bruno se
CA (ρk ) > αCO PT (ρk )
1.9. COMPETITIVITA` CONTRO I VARI TIPI DI AVVERSARI
33
dove A e` la strategia (l’algoritmo) usato da Aldo per dare a Bruno le risposte
αk = a1 , . . . , ak e O PT e` l’algoritmo off-line ottimo usato da Bruno per processare
la stessa sequenza.
Una posizione (ρk , αk ) e` vincente per Bruno se esiste una strategia per Bruno
che gli permetta di raggiungere una posizione immediatamente vincente in un
numero massimo t di passi qualunque siano le risposte date da Aldo.
Come caso particolare, la posizione iniziale (ρ0 , α0 ) e` vincente per Bruno se e
solo se esiste un algoritmo adattivo off-line B tale che per ogni algoritmo on-line
deterministico G si abbia CG (B) > α CB (G).
Supponiamo, per assurdo, che Bruno abbia una strategia vincente contro Aldo
e che questa sia l’algoritmo adattivo off-line B.
Se la strategia di Aldo consiste nell’usare l’algoritmo on-line randomizzato
A = {Ax | x ∈ [0, 1]} allora CAx (B x ) > α CB x (Ax ) per ogni Ax e quindi
E[CAx (B x )] > α E[CB x (Ax )]
e dunque nessun algoritmo on-line randomizzato pu`o essere α-competitivo contro
un avversario adattivo off-line.
Dunque Bruno non pu`o avere una strategia vincente.
Dimostriamo che allora Aldo deve avere una strategia vincente (ossia che
esiste un algoritmo deterministico che e` α-competitivo contro ogni avversario
adattivo off-line).
Una posizione (ρk , αk ) e` vincente per Bruno se e solo se o e` immediatamente vincente, oppure per qualunque risposta ak+1 che possa dare Aldo esiste una
richiesta rk+1 tale che la configurazione (ρk rk+1 , αk ak+1 ) sia vincente. La parte
solo se di questa affermazione deriva immediatamente dalla definizione di posizione vincente. La parte se invece e` vera soltanto nell’ipotesi che Aldo possa dare
soltanto un numero finito di risposte diverse (altrimenti potrebbe non esistere un
limite superiore t per il numero di passi necessari ad arrivare ad una posizione
immediatamente vincente).
Quindi, se (ρk , αk ) non e` vincente per Bruno allora per ogni possibile richiesta
rk+1 proponibile da Bruno esiste una risposta ak+1 che Aldo pu`o dare in modo
tale che anche (ρk rk+1 , αk ak+1 ) non sia vincente per Bruno. La scelta di tale ak+1
e` quindi una strategia vincente per Aldo e tale strategia e` l’algoritmo G on-line
deterministico α-competitivo cercato.
Nota 4 La dimostrazione precedente non e` costruttiva in quanto non dice come
l’algoritmo G determina effettivamente le risposte ai ma dice soltanto che tali
34
CAPITOLO 1. ALGORITMI ON-LINE
risposte esistono. La dimostrazione pu`o essere resa costruttiva (vedi [18]) ma noi
non entreremo nei dettagli tecnici di tale costruzione.
Teorema 1.9.2 Se un algoritmo on-line randomizzato A e` α-competitivo contro
ogni avversario adattivo on-line ed esiste qualche algoritmo on-line randomizzato
H che sia β-competitivo contro qualsiasi avversario ignaro allora A e` anche
αβ-competitivo contro qualsiasi avversario adattivo off-line.
Dimostrazione. Siano A = {Ax : x ∈ [0, 1]} e H = {Hy : y ∈ [0, 1]} i due
algoritmi on-line randomizzati e sia B un avversario adattivo off-line per l’algoritmo A. Scriveremo B x per ricordare che il comportamento di B dipende dai
lanci di monetina di A. Ricaveremo un paio di disuguaglianze che, prese assieme,
dimostrano il teorema.
Consideriamo dapprima B giocare contro A mentre H partecipa al gioco soltanto osservando a distanza ed elaborando la stessa sequenza di richieste che B
propone ad A. Rispetto ad H l’avversario B si comporta come un avversario
ignaro e quindi vale la diseguaglianza
E[CHy (B x )] ≤ β CB x (Ax )
y
qualunque sia la scelta di x ∈ [0, 1] effettuata da A. Prendendo i valori attesi di
entrambi i termini otteniamo la prima disuguaglianza
E E[CHy (B x )] ≤ β E[CB x (Ax )]
x y
x
(1.10)
Consideriamo ora il caso in cui B ed H si coalizzano contro A formando un
avversario adattivo on-line C che genera le richieste usando la stessa strategia di
B ma calcola le sue risposte utilizzando la strategia di H. Il costo di C contro Ax
e` quindi CHy (B x ), in quanto C usa H per calcolare le risposte; invece il costo di
Ax contro C e` CAx (B x ) dato che C usa B per generare le richieste. Siccome A e`
α-competitivo contro ogni avversario adattivo on-line, la disuguaglianza
[CAx (B x )] ≤ α E[CHy (B x )]
E
x
x
vale qualunque sia la scelta di y ∈ [0, 1] effettuata da H. Prendendo i valori attesi
di entrambi i termini otteniamo
E
E[CAx (B x )] ≤ α E
E[CHy (B x )]
y x
y x
1.9. COMPETITIVITA` CONTRO I VARI TIPI DI AVVERSARI
35
Siccome il primo termine non dipende da y possiamo eliminare l’operatore di valore atteso rispetto ad y mentre nel secondo termine possiamo scambiare l’ordine
dei due operatori ottenendo la seconda diseguaglianza
E[CAx (B x )] ≤ α E E[CHy (B x )]
x
x y
(1.11)
Mettendo assieme le disuguaglianze 1.10 e 1.11 otteniamo la disuguaglianza
E[CAx (B x )] ≤ αβ E[CB x (Ax )]
x
x
che dimostra che A e` αβ-competitivo contro qualsiasi avversario adattivo offline.
Mettendo assieme i due teoremi precedenti possiamo ricavare i seguenti corollari
Corollario 1.9.3 Nelle stesse ipotesi del teorema 1.9.2 esiste un algoritmo on-line
deterministico che e` αβ-competitivo.
Esempio 1.9.4 Per il problema della paginazione abbiamo dimostrato un limite
inferiore k per la competitivit`a di ogni algoritmo deterministico on-line ed inoltre
sappiamo che esiste un algoritmo on-line randomizzato H che e` Hk -competitivo
contro ogni avversario ignaro (McGeoch e Sleator in [33]). Sia A un qualsiasi algoritmo on-line randomizzato γ-competitivo contro ogni avversario adattivo on-line. Per il Corollario precedente esiste un algoritmo G deterministico
γHk -competitivo. Siccome k e` un limite inferiore γHk ≥ k e quindi γ ≥ k/Hk .
Dunque k/Hk e` un limite inferiore per il rapporto di competitivit`a di ogni
algoritmo di paginazione on-line randomizzato contro un avversario adattivo online.
Corollario 1.9.5 Se esiste un algoritmo A on-line randomizzato α-competitivo
contro ogni avversario adattivo on-line allora esiste anche un algoritmo on-line
deterministico α2 -competitivo.
Il Corollario 1.9.5 discende dal Teorema 1.9.2 poich´e ogni algoritmo A che risulti α-competitivo contro ogni avversario adattivo on-line e` anche α-competitivo
contro ogni avversario ignaro. Basta quindi prendere H = A e β = α nell’enunciato del Teorema.
Il Corollario 1.9.5 e` sorprendente: dice che per mostrare che esiste un algoritmo competitivo deterministico basta costruire un algoritmo randomizzato che sia
competitivo contro un avversario adattivo on-line.
36
1.10
CAPITOLO 1. ALGORITMI ON-LINE
Analisi dell’algoritmo R ANDOM
Nelle sezioni precedenti abbiamo considerato l’algoritmo di paginazione randomizzato M ARKING e abbiamo dimostrato che esso e` 2Hk -competitivo contro ogni
avversario ignaro. R ANDOM e` un algoritmo di paginazione randomizzato pi`u
semplice di M ARKING: quando incontra un page-fault sceglie casualmente la
pagina da scaricare tra tutte le pagine presenti in memoria. Mostreremo che
Teorema 1.10.1 (Raghavan e Snir [34]) R ANDOM e` k-competitivo contro ogni
avversario adattivo on-line.
Dimostrazione. Indichiamo con B un avversario adattivo on-line. La dimostrazione si basa su di una funzione di potenziale Φ che misura la similarit`a tra il
contenuto della memoria veloce di B e quello della memoria veloce di R ANDOM.
Pi`u precisamente, siano Bi ed Ri le pagine presenti nella memoria di B e
rispettivamente di R ANDOM dopo aver servito la richiesta ri e B0 ed R0 quelle
iniziali. Allora Φi = |Bi ∩ Ri | e` il numero di pagine comuni ai due algoritmi.
Poniamo
Xi = CR ANDOM (ri ) − k (CB (ri ) + Φi − Φi−1 )
Sommando gli Xi relativi a tutta la sequenza di richieste r1 , . . . , rm proposte
dall’avversario B otteniamo
m
i=1
Xi = CR ANDOM (B) − k (CB (R ANDOM) + Φm − Φ0 )
e quindi
m
CR ANDOM (B) = k CB (R ANDOM) + k (Φm − Φ0 ) +
Xi
i=1
Se assumiamo che gli algoritmi partano con la stessa configurazione iniziale
della memoria veloce allora Φ0 = k. Siccome Φm ≤ k la differenza di potenziale
Φm − Φ0 e` minore o uguale a 0. Di conseguenza
m
CR ANDOM (B) ≤ k CB (R ANDOM) +
Xi
i=1
da cui, per la linearit`a del valore atteso
m
E[CR ANDOM (B)] ≤ k E[CB (R ANDOM)] +
E[Xi ]
i=1
1.10. ANALISI DELL’ALGORITMO RANDOM
37
` kSe proviamo che m
i=1 E[Xi ] ≤ 0 avremo quindi dimostrato che R ANDOM e
competitivo contro B.
Per dimostrare la diseguaglianza m
i=1 E[Xi ] ≤ 0 dimostreremo che ciascun
addendo E[Xi ] della sommatoria e` minore o uguale a 0 indipendentemente dagli
altri addendi, ossia che
E[Xi | Bi−1 , Ri−1 ] ≤ 0
qualunque siano gli insiemi di pagine Bi−1 ed Ri−1 presenti nelle memorie veloci
dei due algoritmi prima di processare ri .
Consideriamo quattro casi distinti a seconda che la pagina p richiesta da ri
appartenga o meno a Bi−1 e/o ad Ri−1 .
1. p ∈ Bi−1 e p ∈ Ri−1 .
In questo caso CR ANDOM (ri ) = CB (ri ) = 0. Siccome nessuno dei due
algoritmi modifica la sua memoria Φi − Φi−1 = 0 e quindi
E[Xi | Bi−1 , Ri−1 ] = 0
2. p ∈ Bi−1 e p ∈ Ri−1 .
In questo caso solo R ANDOM ha un page-fault e quindi CR ANDOM (ri ) = 1
e CB (ri ) = 0. R ANDOM sceglie la pagina da eliminare casualmente tra le k
pagine di Ri−1 e quindi sceglier`a una pagina appartenente anche a Bi−1 con
probabilit`a Φi−1 /k. Se la pagina eliminata appartiene a Bi−1 viene eliminata
una pagina comune alle due memorie e ne viene aggiunta una (la pagina p
che diventa comune). Quindi Φi − Φi−1 = 0 con probabilit`a Φi−1 /k. Se
invece la pagina eliminata non appartiene a Bi−1 allora il numero di pagine
comuni aumenta di 1. Dunque Φi − Φi−1 = 1 con probabilit`a (k − Φi−1 )/k.
Pertanto
E[Φi − Φi−1 | Bi−1 , Ri−1 ] = 0 ·
k − Φi−1
Φi−1
Φi−1
+1·
=1−
k
k
k
e pertanto
E[Xi | Bi−1 , Ri−1 ] = 1 − k(0 + 1 −
Φi−1
) = 1 − k + Φi−1
k
Siccome c’`e almeno la pagina p che non e` in comune a Bi−1 ed Ri−1
sappiamo che Φi−1 < k e quindi
E[Xi | Bi−1 , Ri−1 ] ≤ 0
38
CAPITOLO 1. ALGORITMI ON-LINE
3. p ∈ Bi−1 e p ∈ Ri−1 .
In questo caso CR ANDOM (ri ) = 0 e CB (ri ) = 1. Qualsiasi cosa faccia B
il potenziale non pu`o diminuire: o rimane quello di prima oppure aumenta
di 1. Quindi Φi − Φi−1 ≥ 0 ed
Xi = 0 − k(1 + Φi − Φi−1 ) < 0
Dunque
E[Xi | Bi−1 , Ri−1 ] < 0
4. p ∈ Bi−1 e p ∈ Ri−1 .
In questo caso CR ANDOM (ri ) = 1 e CB (ri ) = 1. A differenza dei casi
precedenti, pu`o succedere che il potenziale aumenti di 1, rimanga invariato
oppure diminuisca di 1.
Stimiamo la probabilit`a che il potenziale non diminuisca. A questo scopo
sia q la pagina scaricata da B. Se la pagina q non e` in Ri−1 allora Φi −Φi−1 ≥
0 con probabilit`a 1. Se la pagina q e` in Ri−1 l’algoritmo R ANDOM pu`o
scegliere di scaricare tale pagina q con probabilit`a 1/k (nel qual caso il
potenziale non cambia).
Quindi la probabilit`a che il potenziale non diminuisca e` in ogni caso maggiore o uguale di 1/k e la probabilit`a che diminuisca e` minore o uguale di
1 − 1/k. Dunque
E[Φi − Φi−1 | Bi−1 , Ri−1 ] ≥ 0 ·
1
1
1
+ (−1) · (1 − ) = − 1
k
k
k
e tanto basta per concludere che
E[Xi | Bi−1 , Ri−1 ] ≤ 1 − k(1 +
1
− 1) = 0
k
Quindi E[Xi | Bi−1 , Ri−1 ] ≤ 0 per ogni Bi−1 ed Ri−1 e dunque tale disuguaglianza
vale anche per ogni addendo E[Xi ] della sommatoria m
i=1 E[Xi ]. Pertanto
E[CR ANDOM (B)] ≤ k E[CB (R ANDOM)]
e quindi R ANDOM e` k-competitivo contro ogni avversario adattivo on-line.
1.11. PROBLEMA DEI K SERVER
1.11
39
Problema dei k server
Finora abbiamo trattato argomenti relativi agli algoritmi on-line per il problema
della paginazione. In questa e nelle successive sezioni considereremo un altro problema famoso per la sua apparente semplicit`a, il problema dei k server. Vedremo
che si conosce molto meno per il problema dei k server di quello che si conosce
del problema della paginazione, bench´e esso sia stato intensamente studiato negli
ultimi anni.
Un esempio pratico del problema dei k server e` il seguente: k camerieri debbono servire dei clienti seduti ai tavoli di un grande ristorante. Quando un cliente
deve ordinare schiaccia un apposito pulsante sul tavolo. Il capo cameriere riceve
la richiesta e deve decidere on-line quale cameriere deve recarsi a quel tavolo a
raccogliere l’ordinazione. La funzione costo da minimizzare e` la somma delle
distanze percorse dai k camerieri.
Per dare una formulazione generale del problema dei k server dobbiamo usare
il concetto di spazio metrico:
Definizione 1.11.1 Uno spazio metrico e` un insieme V di punti dotato di una
funzione distanza d(u, v) tale che
1. d(u, v) ≥ 0 per ogni u, v ∈ V
2. d(u, v) = 0 se e solo se u = v
3. d(u, v) = d(v, u) per ogni u, v ∈ V
4. d(u, v) + d(v, w) ≥ d(u, w) per ogni u, v, w ∈ V .
In altre parole la distanza d(u, v) e` non negativa, e` positiva tra punti distinti, e` simmetrica e soddisfa la disuguaglianza triangolare. Spesso, ma non necessariamente,
nel problema dei k server lo spazio V e` finito.
Definizione 1.11.2 (Problema dei k server) I dati del problema sono uno spazio
metrico V , un insieme di k “server” posizionati in punti di V ed una successione
di richieste r1 , r2 , . . . , rn , ciascuna delle quali e` un punto di V . Ad ogni richiesta
bisogna muovere uno dei server dal punto in cui esso si trova al punto richiesto.
Lo scopo e` minimizzare la distanza totale percorsa da tutti i server per servire
tutte le richieste.
40
CAPITOLO 1. ALGORITMI ON-LINE
Diremo configurazione la lista a1 , . . . , ak delle k posizioni in cui si trovano i
server (ammetteremo la possibilit`a che pi`u server si possano trovare nello stesso
punto, ossia che ai = aj con i = j).
La soluzione ottima del problema dei k server si pu`o calcolare off-line usando
la programmazione dinamica (e quindi in tempo polinomiale). E` anche possibile
trasformare il problema in un problema di flusso su di una opportuna rete di flusso.
Asserzione 1 Per ogni sequenza di richieste, siano esse da soddisfare on-line od
off-line, basta muovere un solo server per ciascuna richiesta.
Dimostrazione. Supponiamo che per rispondere ad una richiesta rt venga mosso
il server i e che, allo scopo di minimizzare il costo totale, venga mosso anche
il server j in qualche altra posizione (ad esempio per coprire la zona lasciata
scoperta dal server i o per qualche altra considerazione strategica). Se il server j
non verr`a pi`u usato il costo del suo movimento e` certamente sprecato. Assumiamo
quindi che il server j venga usato per una successiva richiesta rs . In questo caso,
per la disuguaglianza triangolare, il server j avrebbe potuto andare direttamente
in rs partendo dalla sua posizione originaria con un costo non maggiore di quello
pagato passando per la posizione intermedia da lui raggiunta dopo la richiesta
rt .
Grazie alla disuguaglianza triangolare possiamo quindi limitarci a muovere un
solo server alla volta, anche se qualche volta, per facilitare l’analisi considereremo
algoritmi che muovono contemporaneamente pi`u di un server.
1.11.1
Casi particolari del problema dei k server
Paginazione Il problema della paginazione e` un caso particolare del problema dei
k server in cui i server sono le k posizioni in memoria veloce, V e` l’insieme
di pagine e d(u, v) = 1 per ogni u = v. In altre parole la paginazione e`
proprio il problema dei k server con la distanza uniforme.
Disco con due testine Abbiamo un disco magnetico rotante su cui sono registrate
delle tracce concentriche. Due testine di lettura/scrittura possono muoversi
radialmente sulle tracce. Le due testine sono posizionate una di fronte all’altra per cui non possono sovrapporsi o incrociarsi. Il costo e` la somma
delle distanze lineari che le due testine debbono percorrere per servire tutta
la sequenza di richieste di I/O.
1.11. PROBLEMA DEI K SERVER
1.11.2
41
Riassunto dei risultati noti
Alcuni risultati per il problema della paginazione possono essere generalizzati al
problema dei k server. I risultati positivi non si possono generalizzare direttamente
ma, siccome la paginazione e` un caso particolare del problema dei k server, i limiti
inferiori per la paginazione sono anche limiti inferiori per il problema dei k server.
Teorema 1.11.3 (Manasse-McGeoch-Sleator [32]) Per il problema dei k server
non esiste un algoritmo α-competitivo con α < k qualunque sia lo spazio metrico.
La dimostrazione generale e` simile a quella per la metrica uniforme (quella
per il problema della paginazione).
Per il problema della paginazione abbiamo un algoritmo k-competitivo. L’esistenza di un algoritmo k-competitivo per il problema generale dei k server e`
invece ancora un problema aperto. Per un certo tempo si ignorava persino se esistesse una algoritmo f (k)-competitivo per qualche funzione f (k) di k. Il primo
risultato in questo senso e` dovuto a Fiat, Rabani e David che hanno dimostrato il
seguente teorema per induzione su k
Teorema 1.11.4 (Fiat-Rabani-David [25]) Per il problema generale dei k server
esiste un algoritmo f (k)-competitivo con f (k) = O(k k ).
Sono stati proposti un gran numero di risultati parziali tra i quali:
Risultati relativi a specifici valori di k
k = 1 Questo caso e` banale in quanto non abbiamo alcuna scelta su quale server
mandare. Quindi ogni ragionevole algoritmo e` 1-competitivo.
k = 2 Esiste un algoritmo 2-competitivo per questo caso, dovuto a Manasse, McGeoch e Sleator [32]. Anche per questo piccolo valore di k l’algoritmo non
e` banale. Si sa che anche l’algoritmo della funzione lavoro e` 2-competitivo
in questo caso (vedi [22]). Per il problema dei 2 server si e` anche lavorato per sviluppare algoritmi competitivi veloci, nel senso che essi richiedono
soltanto una quantit`a costante di lavoro per ogni richiesta (vedi [27, 19, 29]).
k = |V | − 1 In questo caso esiste un algoritmo BALANCE che vedremo in seguito
e che e` k-competitivo [32]. Si sa anche che una variazione di BALANCE e`
10-competitiva per il caso k = 2 (Irani e Rubinfield [27]).
42
CAPITOLO 1. ALGORITMI ON-LINE
Risultati per spazi metrici particolari
paginazione Per la paginazione abbiamo visto un algoritmo k-competitivo.
rette, alberi, reti resistive Per tutte queste configurazioni si sa che esiste un algoritmo k-competitivo [20], [23].
cerchio Per punti su di un cerchio e` stato proposto un algoritmo k 3 -competitivo.
Ora si conosce un risultato generale dovuto a Chroback e Larmore [22] che
nel 1992 hanno proposto un algoritmo generale, detto della funzione lavoro, ed
hanno dimostrato che esso e` 2-competitivo per k = 2. Soltanto alcuni anni dopo
Koutsoupias and Papadimitriou [30] hanno dimostrato che l’algoritmo della funzione lavoro e` (2k − 1)-competitivo; e` un problema aperto se tale algoritmo sia in
realt`a k-competitivo.
1.11.3
Alcune semplici strategie.
L’algoritmo goloso G REEDY
L’algoritmo pi`u banale per il problema dei k server e` G REEDY che serve ogni
richiesta usando sempre il server pi`u vicino. Il seguente esempio illustra il principale difetto di G REEDY.
Consideriamo due server 1 e 2 e due punti a e b posti sulla retta reale (con la
metrica Euclidea) nel modo seguente:
1
2
a
b
Prendiamo la sequenza di richieste abababababab . . .. G REEDY serve tutte le
richieste usando il server 2 in quanto il server 2 e` sempre quello pi`u vicino sia ad
a che a b. Un algoritmo che muove il server 1 in a alla prima richiesta ed il server
2 in b alla seconda richiesta risponde a tutte le successive richieste con costo 0.
Quindi G REEDY non e` α-competitivo per nessun α.
L’algoritmo BALANCE
L’algoritmo BALANCE tiene conto della distanza totale Di percorsa da ciascun
server i e cerca di pareggiare tali distanze tra tutti i server. Quando arriva una
richiesta r essa viene servita da un server i per il quale la quantit`a Di + d(ai , r) e`
1.11. PROBLEMA DEI K SERVER
43
minima dove Di e` la distanza percorsa fino a quel momento dal server i e d(ai , r)
e` la distanza che il server i deve percorrere per servire la richiesta r muovendosi
dalla posizione ai in cui si trova. L’algoritmo BALANCE e` k-competitivo se |V | =
k + 1 ma in generale non e` α competitivo per nessun α. Il seguente controesempio
e` dovuto a Jon Kleingerg. Consideriamo due server (k = 2) che si muovono
sullo spazio costituito dai quattro vertici A, B, C, D di un rettangolo di altezza
h = d(A, B) = d(C, D) molto minore della base b = d(B, C) = d(A, D) come
illustrato nella seguente figura:
B
C
h
b
A
D
Se all’inizio i server sono in C e D e la sequenza di richieste e` la sequenza
ciclica ABCDABCD . . ., il costo di BALANCE e` b per ogni richiesta mentre
quello di O PT e` h per ogni richiesta tranne la prima.
Una piccola variazione di BALANCE che minimizza Di + 2d(ai , r) invece di
Di + d(ai , r) risulta invece 10-competitiva per k = 2 (vedi [27]).
L’algoritmo randomizzato H ARMONIC
Bench´e l’algoritmo G REEDY non funzioni molto bene, l’intuizione di usare il
server pi`u vicino risulta utile se la randomizziamo un po’. Invece di usare sempre
il server pi`u vicino scegliamo il server da usare in modo casuale con probabilit`a
inversamente proporzionale alla sua distanza dal punto richiesto.
Indicato con d−1 (ai , r) = d(a1i ,r) l’inverso della distanza d(ai , r) del server i
dal punto richiesto r, la probabilit`a con cui scegliamo un server i e` quindi
p(i) =
d−1 (ai , r)
k
−1
j=1 d (aj , r)
dove la sommatoria e` estesa a tutti i k server.
L’algoritmo che si ottiene in questo modo viene detto H ARMONIC ed e` competitivo come affermato nel seguente
Teorema 1.11.5 (Grove [26]) H ARMONIC e` ( 45 k2k − 2k)-competitivo rispetto ad
ogni avversario adattivo on-line.
44
CAPITOLO 1. ALGORITMI ON-LINE
Prima di questo risultato si sapeva soltanto che l’algoritmo H ARMONIC era
3
-competitivo per k = 3 e 3-competitivo per k = 2 (vedi [21]).
Si conosce inoltre un limite inferiore per questo algoritmo. Per alcuni particolari avversari B adattivi on-line si pu`o dimostrare che
17000
E[CH ARMONIC (B)] =
k+1
2
E[CB (H ARMONIC)]
`
Non possiamo quindi sperare che esso sia meglio di k+1
2 -competitivo. E un
problema aperto se il rapporto di competitivit`a di H ARMONIC sia uguale a tale
limite inferiore.
Infine, ricordiamo che se conosciamo un algoritmo randomizzato α-competitivo possiamo ricavare un algoritmo on-line deterministico α2 -competitivo. Possiamo quindi trovare un algoritmo deterministico ( 54 k2k − 2k)2 -competitivo (ma
l’algoritmo che otteniamo in questo modo e` tutt’altro che efficiente).
1.12
Un algoritmo k competitivo sugli alberi
I risultati di questa sezione sono dovuti a Chrobak e Larmore [20]. Sia (V, E) un
albero (grafo non orientato aciclico) con una lunghezza positiva d(e) associata a
ciascun arco e. Possiamo rappresentare ogni arco e con un segmento di lunghezza
d(e).
Sia V lo spazio metrico costituito dall’insieme di punti su tali segmenti con distanza d(u, v) la lunghezza del cammino da u a v misurata sulla rappresentazione
dell’albero.
Assumiamo che le richieste siano dei punti arbitrari di V . L’algoritmo che
vedremo si pu`o anche applicare al caso discreto in cui tutte le richieste sono sui
vertici dell’albero ma per comodit`a tratteremo il caso continuo.
Siccome un albero e` un grafo aciclico vi e` un unico cammino che congiunge
il punto ai in cui si trova un server i al punto in cui e` localizzata una richiesta r.
Questo fatto giustifica la seguente
Definizione 1.12.1 Un server i si dice attivo quando viene effettuata la richiesta
r se lungo il cammino da ai ad r non ci sono altri server. Nel caso in cui pi`u
server si trovino nello stesso punto (ad esempio in un vertice) soltanto uno di essi
pu`o essere attivo (la scelta pu`o essere resa deterministica ordinando i server e
prendendo il primo).
1.12. UN ALGORITMO K COMPETITIVO SUGLI ALBERI
45
L’algoritmo ATTIVI e` facile da descrivere: per servire una richiesta r tutti i
server attivi si muovono verso r alla stessa velocit`a e ciascuno di essi si ferma
quando:
1. diventa inattivo perch`e oscurato da un altro server che si frappone tra di esso
e la richiesta r;
2. raggiunge la destinazione r, nel qual caso si fermano anche tutti gli altri
server.
1.12.1
Dimostrazione della k-competitivit`a
Useremo una funzione potenziale per dimostrare che per ogni sequenza di richieste
ρ = r1 , . . . rn
vale la diseguaglianza
CATTIVI (ρ) ≤ k CO PT (ρ)
La funzione potenziale dipende dalla configurazione A = a1 , . . . , ak in cui si
trovano i server di ATTIVI e la configurazione B = b1 , . . . , bk in cui si trovano i
server di O PT ed e` definita nel modo seguente:
Φ=
d(ai , aj ) + k D(A, B)
i<j
dove i<j d(ai , aj ) misura la dispersione dei server di ATTIVI mentre D(A, B)
misura la distanza dei server di ATTIVI dai server di O PT ossia e` il costo minimo per spostare i server di ATTIVI dalla configurazione A in cui si trovano alla
configurazione B in cui si trovano i server di O PT e quindi
k
D(A, B) = min
π
d(aπ(i) , bi )
i=1
dove il minimo e` calcolato su tutte le permutazioni π di a1 , . . . , ak .
Immaginiamo che ogni richiesta rt venga processata prima da O PT e subito
˜ t il valore della funzione potenziale dopo che O PT abbia
dopo da ATTIVI. Sia Φ
processato la richiesta rt ma prima che tale richiesta sia stata processata da ATTIVI
e sia Φt il valore della funzione potenziale dopo che sia ATTIVI che O PT abbiano
processato la richiesta rt .
46
CAPITOLO 1. ALGORITMI ON-LINE
Dimostreremo che valgono le due diseguaglianze
˜ t − Φt−1 ≤ k C
Φ
O PT (rt )
e
˜ t ≤ −C
Φt − Φ
ATTIVI (rt )
dalle quali discende immediatamente che
Φt − Φt−1 ≤ k CO PT (rt ) − CATTIVI (rt )
e, sommando su tutti i t
Φn − Φ0 ≤ k CO PT (ρ) − CATTIVI (ρ)
e siccome Φn ≥ 0
CATTIVI (ρ) ≤ k CO PT (ρ) + Φ0
Assumendo che all’inizio i server dei due algoritmi si trovino tutti ammassati
nello stesso punto abbiamo Φ0 = 0 e quindi
CATTIVI (ρ) ≤ k CO PT (ρ)
che prova la k-competitivit`a di ATTIVI. Ci rimane quindi soltanto da provare il
seguente Lemma 1.12.2.
Lemma 1.12.2 Sia Φt−1 il potenziale prima che i due algoritmi abbiano proces˜ t il potenziale dopo che soltanto O PT abbia processato rt e
sato la richiesta rt , Φ
Φt il potenziale dopo che entrambi gli algoritmi abbiano processato rt . Valgono
le due disequazioni:
˜ t − Φt−1 ≤ k C
Φ
O PT (rt ),
˜ t ≤ −C
Φt − Φ
ATTIVI (rt ).
(1.12)
(1.13)
Dimostrazione. Consideriamo dapprima cosa succede quando l’algoritmo O PT
muove un server b per soddisfare la richiesta r percorrendo la distanza d =
d(b , r) (ricordiamo che possiamo assumere che O PT muova un solo server alla
volta). Siccome le posizioni dei server di ATTIVI non cambiano il primo addendo i<j d(ai , aj ) della funzione potenziale non cambia. Consideriamo quindi la
variazione ∆D del secondo addendo.
Il costo minimo D(A, B) per muovere i server di ATTIVI nelle posizioni dei
server di O PT pu`o aumentare al pi`u della distanza d percorsa dall’unico server b che si muove. Infatti prima che O PT processi r abbiamo D(A, B) =
1.12. UN ALGORITMO K COMPETITIVO SUGLI ALBERI
47
k
i=1
d(aπ(i) , bi ) dove π e` una permutazione che lo rende minimo. Dopo che
O PT ha spostato b in r esso si trova nella configurazione B = B − b + r e
D(A, B ) ≤ ki=1 d(aπ(i) , bi ) in quanto non e` detto che π sia la permutazione che
lo minimizza. Ma
k
d(aπ(i) , bi ) = D(A, B) + d(aπ( ) , r) − d(aπ( ) , b )
i=1
in quanto O PT sposta soltanto il server b in r. Per la disuguaglianza triangolare
d(aπ( ) , r) ≤ d(aπ( ) , b ) + d(b , r) = d(aπ( ) , b ) + d
e quindi ∆D = D(A, B ) − D(A, B) ≤ d(aπ( ) , r) − d(aπ( ) , b ) ≤ d.
Dunque
˜ t − Φt−1 = k ∆D ≤ k d = k C
Φ
O PT (rt )
il che prova la diseguaglianza 1.12 del Lemma 1.12.2.
Vediamo ora come cambia la funzione potenziale quando ATTIVI muove i suoi
server. Per comodit`a di esposizione numeriamo i server di ATTIVI in modo tale
che a1 , a2 , . . . , aq siano i server attivi e aq+1 , . . . , ak siano quelli inattivi. I server
attivi si muovono tutti alla stessa velocit`a verso la richiesta.
Dividiamo i percorsi in passi in corrispondenza degli istanti in cui uno o pi`u
dei server attivi diventano inattivi e calcoliamo la variazione di potenziale relativa
ad un singolo passo. La Figura 1.4 e` un esempio di tale suddivisione in passi.
Calcoliamo dapprima la variazione ∆D di D(A, B). Sia ah il server che nel
calcolo di D(A, B) e` abbinato al server b spostato da O PT per servire la richiesta
rt . Siccome b si trova in rt , possiamo assumere che ah sia un server attivo (se esso
fosse inattivo potremmo scambiarlo con il server attivo che lo copre ottenendo un
valore di D(A, B) minore o uguale).
Sia d lo spostamento dei server attivi in uno dei passi. La distanza tra ah e b
diminuisce di d mentre la distanza tra ogni altro server attivo ed il server di O PT
ad esso abbinato in D(A, B) pu`o al pi`u aumentare di d. Dunque
∆D ≤ (q − 1)d − d = (q − 2)d
Per calcolare la variazione ∆S di S =
1. La parte ∆SI = ∆
q<i<j
i<j
d(ai , aj ) dividiamola in tre parti:
d(ai , aj ) relativa alle distanze tra server inattivi.
Siccome i server inattivi non si muovono
∆SI = 0
48
CAPITOLO 1. ALGORITMI ON-LINE
3
3
5
5
2
2
r
r
4
6
1
6
1
4
stato iniziale
Passo 1
5
3
3
5
2
r
2
4
6
1
6
r
4
1
Passo 3
Passo 2
Figura 1.4: Suddivisione in passi dello spostamento contemporaneo dei server
attivi (in rosso) verso la posizione richiesta (in verde). I server inattivi (in blu)
rimangono fermi.
2. La parte ∆SA = ∆
i<j≤q
d(ai , aj ) relativa alle distanze tra server attivi.
Siccome tutti i server attivi si avvicinano alla posizione della richiesta di
una distanza d, la distanza tra due server attivi diminuisce di 2d. Quindi
∆SA = −2d
3. La parte ∆SAI = ∆
dai server inattivi.
i≤q<j
q
2
= −d q(q − 1)
d(ai , aj ) relativa alle distanze dei server attivi
1.12. UN ALGORITMO K COMPETITIVO SUGLI ALBERI
49
Per ognuno dei k − q server inattivi vi e` un server attivo che si allontana da
esso e q − 1 server attivi che gli si avvicinano. Quindi
∆SAI = (k − q)(d − (q − 1)d) = (k − q)(2 − q)d
Sommando k∆D con le tre parti ∆SI , ∆SA e ∆SAI di ∆S otteniamo la
variazione di potenziale relativa ad un passo
∆Φ ≤ d[k(q − 2) − q(q − 1) + (k − q)(2 − q)]
= d[kq − 2k − q 2 + q + 2k − kq − 2q + q 2 )]
= −dq
Siccome dq e` esattamente il costo pagato da ATTIVI per muovere i q server attivi della distanza d, possiamo dire che ad ogni passo vi e` una diminuzione del
potenziale almeno pari al costo pagato da ATTIVI. Sommando su tutti i passi p
otteniamo
˜t ≤ −
Φt − Φ
dp qp = −CATTIVI (ri )
p
che e` la disuguaglianza 1.13 del Lemma 1.12.2 che volevamo provare.
Esercizio 1 Considerare un albero a forma di stella con un vertice centrale c collegato ad n vertici periferici con n archi di lunghezza 1/2 su cui si muovono k
server. Interpretare gli n vertici periferici come l’insieme delle pagine in un problema di paginazione ed i k server come celle di memoria veloce. Descrivere
l’algoritmo di paginazione, detto F WF (per Flush When Full), che si ottiene e
compararlo con M ARKING. Dire come si possa facilmente modificare F WF per
risolvere il problema di paginazione generalizzato in cui il costo di scambiare due
pagine p e q in memoria veloce non e` 1 ma f (p) + f (q) con f (x) ≥ 0 per ogni
pagina x.
Esercizio 2 Dimostrare che
k
D(A, B) = min
π
d(aπ(i) , bi )
i=1
e` una metrica per lo spazio delle configurazioni dei k server.
50
1.13
CAPITOLO 1. ALGORITMI ON-LINE
Spazi metrici resistivi
Useremo la teoria dei circuiti elettrici per illustrare un algoritmo randomizzato
per il problema dei k-server dovuto a Coppersmith, Doyle, Raghavan e Snir [23].
Questo algoritmo risulta k-competitivo contro un avversario adattivo on-line su di
una certa classe di spazi metrici.
Un circuito elettrico e` un multigrafo non orientato G = (V, E) in cui ad ogni
arco e ∈ E e` associato un peso C(e) = 1/R(e). La quantit`a R(e) > 0 viene detta
resistenza dell’arco e il suo reciproco C(e) viene detto conduttanza.
Per comodit`a di esposizione assumiamo V = {1, 2, . . . , n}. Ci possiamo allora chiedere quale sia la resistenza effettiva ri,j tra due vertici qualsiasi i e j, ossia
la resistenza che viene opposta al passaggio della corrente quando applichiamo
una differenza di potenziale tra i due vertici i e j. La conduttanza effettiva ci,j
sar`a sempre il reciproco della resistenza effettiva.
i
R1
R2
R3
R4
j
Figura 1.5: Resistenze in serie. La resistenza effettiva tra i e j e` la somma delle
resistenze ri,j = R1 +R2 +R3 +R4 .
Per resistenze in serie la resistenza effettiva e` la somma delle resistenze dei
singoli archi (Figura 1.5) mentre per resistenze in parallelo la conduttanza effettiva
e` la somma delle conduttanze dei singoli archi (Figura 1.6).
La seconda propriet`a ci permette di considerare soltanto circuiti il cui grafo
G e` semplice. Basta infatti sostituire gli archi multipli con un solo arco la cui
conduttanza e` la somma delle conduttanze. Possiamo anche completare il grafo
aggiungendo tutti gli archi mancanti con conduttanza nulla. Un circuito rimane
quindi definito dalla sua matrice delle conduttanze dirette C = [Ci,j ] dove i vertici i e j sono connessi dalla resistenza R(ij) = 1/Ci,j se e solo se Ci,j > 0.
Convenzionalmente poniamo Ci,i = ∞.
Queste due regole non sono sempre sufficienti per determinare la resistenza
effettiva tra due vertici in un circuito elettrico qualsiasi (ad esempio il grafo completo con 4 vertici). In generale bisogna ricorrere alla relazione V = RI (che lega
la differenza di potenziale V alla resistenza R ed all’intensit`a di corrente I) ed
alla prima legge di Kirchoff (che dice che la somma delle correnti che entrano in
un vertice e` uguale alla somma delle correnti che ne escono).
1.13. SPAZI METRICI RESISTIVI
51
R1
R2
i
j
R3
R4
Figura 1.6: Resistenze in parallelo. La conduttanza effettiva tra i e j e` la somma
delle conduttanze ci,j = R11 + R12 + R13 + R14 .
j
3
i
j
11
3
4
5
k
i
11
2
11
k
Figura 1.7: A sinistra la matrice delle distanze (interpretate come resistenze
effettive). A destra le corrispondenti resistenze degli archi.
Definizione 1.13.1 Una metrica con matrice delle distanze D = [di,j ] si dice
resistiva se essa e` la matrice delle resistenze effettive di qualche circuito elettrico.
Noi useremo le resistenze effettive di un circuito elettrico come distanze di
una metrica. Questo e` giustificato dal seguente
Fatto 1 La matrice R = [ri,j ] delle resistenze effettive di un circuito elettrico e`
simmetrica e soddisfa la disuguaglianza triangolare ri,j + rj,k ≤ ri,k .
Il viceversa non e` generalmente vero. Vi sono metriche la cui matrice delle
distanze D non e` resistiva. Chiameremo metriche resistive quelle metriche la cui
matrice delle distanze e` resistiva.
Quali sono le metriche resistive? Ecco tre esempi.
1. Una matrice simmetrica D di dimensione 3 × 3 che soddisfa la disuguaglianza triangolare e` sempre resistiva. In altre parole per le matrici 3 × 3
vale anche il viceversa del Fatto 1. Come esempio consideriamo un circuito
triangolare con resistenze effettive 3, 4 e 5 (Figura 1.7). Le corrispondenti
52
CAPITOLO 1. ALGORITMI ON-LINE
resistenze degli archi sono 11
, 11
e 11. Verifichiamolo per i due vertici j
3
2
e k. Dobbiamo verificare che la resistenza effettiva sia 4. Consideriamo i
due cammini da j a k; essi hanno resistenze rispettive 11
+ 11 = 44
e 11
e
3
3
2
2
3
e 11
. Siccome tali due cammini sono in parallelo la
quindi conduttanze 44
2
3
+ 11
= 14 e quindi la resistenza effettiva
conduttanza effettiva tra j e k e` 44
e` 4.
2. Una metrica su di un albero e` sempre resistiva. Per vederlo basta porre
come resistenza di un arco e la sua lunghezza. Siccome tra due vertici i e
j vi e` soltanto un cammino la resistenza effettiva tra i e j e` la somma delle
resistenze degli archi di tale cammino.
3. Consideriamo una rete di calcolatori rappresentata con un grafo in cui i
vertici sono i calcolatori e gli archi i collegamenti di rete. A ciascun arco e` associata una velocit`a di trasmissione in Kbyte/sec (la conduttivit`a).
Il reciproco della conduttivit`a rappresenta il numero di secondi necessari
a trasmettere un Kbyte (la resistenza). E` evidente che per collegamenti in
serie si sommano le resistenze mentre per collegamenti in parallelo si sommano le conduttivit`a. Inoltre vale sicuramente la prima legge di Kirchoff (a
meno che i messaggi non si perdano per strada). Possiamo quindi usare come metrica la resistenza effettiva tra due vertici (ossia il numero di secondi
necessari per trasmettere un messaggio di 1 Kbyte da uno all’altro vertice
attraverso la rete).
Un’altra propriet`a delle metriche resistive e` la seguente
Lemma 1.13.2 Se la matrice delle distanze D e` resistiva allora anche ogni sottomatrice indotta e` resistiva.
Una sottomatrice indotta si ottiene rimuovendo alcune righe e le corrispondenti colonne, ossia rimuovendo alcuni vertici del circuito.
Osserviamo che il circuito elettrico relativo alla sottomatrice non e` generalmente uguale al circuito che si ottiene da quello relativo alla matrice D eliminando
semplicemente i nodi corrispondenti e gli archi incidenti ma occorre aggiungere
alcuni archi per tener conto delle resistenze che sono state tolte.
Come possiamo allora trovare un tale circuito data la matrice resistiva D =
[di,j ]? Noi descriveremo, senza dimostrarlo, un algoritmo che data la matrice
resistiva D = [di,j ] calcola la matrice delle conduttanze dirette C = [Ci,j ] di un
tale circuito. Gli archi del circuito saranno quindi gli archi ij tali che Ci,j > 0 e
la loro resistenza sar`a il reciproco R(ij) = 1/Ci,j .
1.13. SPAZI METRICI RESISTIVI
n
0
j
1
˜ n−1
D
i
d˜i,j
n−1
n 0 ... 0
...
j
1
n−1
1
∞
n
j
..
.
C˜i,j
0
..
.
0
˜
D
C˜
Ci,j
Ci,n
1
53
Cn,j
∞
C
Figura 1.8: Illustrazione della Procedura 1.13.3. Passo 1: calcola d˜i,j = (dn,i +
˜ n−1 )−1 . Passo 3: pone Ci,j = −C˜i,j per
dn,j − di,j )/2. Passo 2: calcola C˜ = (D
i = j. Passo 4: calcola Ci,n = Cn,i = C˜i,i − n−1
j=1 Cj,i . Passo 5: pone Ci,i = ∞.
j=i
Procedura 1.13.3 Supponiamo che la matrice D abbia dimensioni n × n. La
procedura si compone dei seguenti passi:
˜ = [d˜i,j ] ponendo d˜i,j = (dn,i + dn,j − di,j )/2.
1. Costruiamo la matrice D
Notiamo che d˜i,j ≥ 0 per la disuguaglianza triangolare. Inoltre l’ultima riga
˜ sono nulle, infatti d˜n,j = (dn,n + dn,j − dn,j )/2 = 0
e l’ultima colonna di D
e analogamente d˜i,n = (dn,i + dn,n − di,n )/2 = 0.
˜ n−1 la matrice (n−1) × (n−1) ottenuta da D
˜ eliminando l’ultima riga
2. Sia D
˜ n−1 )−1 .
e l’ultima colonna. Calcoliamo la matrice inversa C˜ = (D
3. Poniamo Ci,j = −C˜i,j per ogni i, j < n e i = j.
4. Poniamo Ci,n = Cn,i =
n−1
j=1
C˜j,i .
Osserviamo che per la simmetria di C e il punto 3 questo e` equivalente a
n−1
Cn,i = C˜i,i −
n
Cj,i
j=1
j=i
Cj,i = C˜i,i
ossia
j=1
j=i
5. Infine poniamo Ci,i = ∞ per ogni i.
Si pu`o dimostrare che se D e` resistiva la Procedura 1.13.3 fornisce la corrispondente matrice C = [Ci,j ] di conduttanze dirette non negative.
54
CAPITOLO 1. ALGORITMI ON-LINE
1.13.1
L’algoritmo RWALK
L’algoritmo RWALK per il problema dei k server opera nel modo seguente. Assumiamo, senza perdita di generalit`a, che la t-esima richiesta sia nel vertice 1 e
che prima di soddisfare la richiesta rt = 1 i server di RWALK si trovino nei vertici
2, . . . , k+1. Sia D la sottomatrice indotta della matrice delle distanze relativa ai
k+1 vertici 1, . . . , k, k+1 e supponiamo che essa sia resistiva. Possiamo allora
calcolare la corrispondente matrice delle conduttanze dirette C = [Ci,j ] usando la
Procedura 1.13.3.
L’algoritmo sceglie quindi casualmente di muovere il server in posizione i con
la probabilit`a
Ci,1
Pr[i → 1] = k+1
j=2 Cj,1
La probabilit`a Pr[i → 1] e` sempre definita in quanto il denominatore non pu`o
risultare nullo, altrimenti il punto 1 in cui si trova la richiesta non sarebbe raggiungibile da nessuno degli altri k punti in cui si trovano i server.
Osserviamo che ad una piccola distanza (resistenza) corrisponde una grande conduttanza e quindi una maggiore probabilit`a. Questo e` in accordo con
l’intuizione che suggerisce di muovere preferibilmente i server pi`u vicini.
Teorema 1.13.4 Se tutte le sottomatrici indotte D di dimensioni (k+1) × (k+1)
sono resistive RWALK e` k-competitivo contro ogni avversario adattivo on-line.
Due casi importanti coperti da questo teorema sono
• problema dei k server con k = 2 (e metrica qualsiasi). RWALK funziona ed
e` 2-competitivo.
• k server su di un albero. Sappiamo che la metrica e` resistiva e quindi anche
ogni sottomatrice indotta e` resistiva (Lemma 1.13.2). RWALK funziona ed
e` k-competitivo.
Dimostrazione. Dobbiamo dimostrare che
E[CRWALK (B)] ≤ k E[CB (RWALK)] + c
dove B e` un avversario adattivo on-line e c e` una costante. Possiamo riscrivere la
precedente disequazione come
E[CRWALK (B) − kCB (RWALK)] ≤ c
1.13. SPAZI METRICI RESISTIVI
55
Noi dimostreremo in realt`a la disequazione pi`u stretta
E[Φ + CRWALK (B) − kCB (RWALK)] ≤ c
dove Φ e` una funzione potenziale non negativa.
Per fare questo dimostreremo la diseguaglianza
E[∆Φt + CRWALK (rt ) − kCB (rt )] ≤ 0
dove CRWALK (rt ) e CB (rt ) sono i costi pagati rispettivamente da RWALK e dall’avversario B per soddisfare la richiesta t-esima rt e ∆Φt = Φt − Φt−1 e` la
differenza di potenziale corrispondente.
Sommando su tutta la sequenza di n richieste otteniamo
E[Φn − Φ0 + CRWALK (B) − kCB (RWALK)] ≤ 0
Siccome Φ ≥ 0 basta prendere c = Φ0 per concludere che RWALK e` k-competitivo contro B.
Sia A = a1 , . . . , ak la configurazione dei server di RWALK e B = b1 , . . . , bk
quella dei server dell’avversario B. La funzione potenziale da noi scelta e`
Φ(A, B) =
dai ,aj + kD(A, B)
i<j
dove la prima parte e` una misura della dispersione dei server di RWALK e la seconda parte D(A, B) e` una misura della distanza tra i server di RWALK e quelli di
B. Questa seconda parte e` k volte il costo D(A, B) di una matching minimo tra
A e B. Ricordiamo che il costo del matching minimo e`
k
D(A, B) = min
π
daπ(i) ,bi
i=1
dove il minimo e` calcolato su tutte le permutazioni π dei server della configurazione A. Osserviamo che Φ(A, B) ≥ 0 come richiesto.
Per valutare la differenza di potenziale ∆Φt assumiamo che la richiesta rt
venga soddisfatta in due fasi. Nella prima fase la richiesta viene soddisfatta dall’avversario B mentre RWALK rimane fermo. Nella seconda fase la richiesta viene
soddisfatta dall’algoritmo RWALK mentre l’avversario B rimane fermo.
˜ t il potenziale subito dopo la prima fase. Possiamo allora scomporre la
Sia Φ
˜ t − Φt−1 e ∆Φ = Φt − Φ
˜ t relative
differenza di potenziale in due parti ∆Φt = Φ
t
alle due fasi.
Consideriamo separatamente le due fasi.
56
CAPITOLO 1. ALGORITMI ON-LINE
Prima fase L’avversario muove un server b nella posizione rt .
Quindi ∆Φt ≤ kdb ,rt in quanto lo stesso matching che aveva il costo minimo D(A, B) prima dello spostamento del server, dopo lo spostamento ha
un costo aumentato al pi`u della distanza db ,rt . Dunque ∆D(A, B) ≤ db ,rt .
Il costo pagato dall’avversario per processare rt e` CB (rt ) = db
,rt
e quindi
E[∆Φt − kCB (rt )] ≤ 0
Seconda fase L’algoritmo RWALK muove un server.
Per semplicit`a di esposizione supponiamo che i server di RWALK si trovino nei vertici 2, . . . , k, k+1 (ossia che per ogni i = 1, . . . , k il server i di
RWALK si trovi nella posizione ai = i + 1), che la richiesta rt sia nel vertice
1 e che il server di B che e` stato mosso nella posizione rt sia il server k di B
per cui, dopo lo spostamento, bk = rt . Supponiamo inoltre che il matching
di costo minimo sia (a1 , b1 ), . . . , (ak , bk ). (Possiamo sempre rinumerare i
vertici ed i server in modo da soddisfare queste condizioni.)
Sia h il server mosso da RWALK dalla sua posizione iniziale ah = h + 1 alla
posizione bk = rt = 1. Consideriamo il matching ottenuto da quello di costo minimo (a1 , b1 ), . . . , (ak , bk ) sostituendo rispettivamente le due coppie
(ak , bk ) e (ah , bh ) con le due coppie (ak , bh ) e (ah , bk ) come illustrato nella
figura seguente
a1 =2
ah =h+1
ak =k+1
b1
bh
bk =rt =1
Se D(A, B) e` il costo del matching minimo prima dello spostamento del server h dalla posizione ah = h + 1 alla posizione rt = 1, dopo lo spostamento
il costo del matching modificato e`
D(A, B) + dak ,bh − dak ,bk − dah ,bh
che sar`a certamente maggiore o uguale al costo del matching minimo dopo
lo spostamento del server. Pertanto
∆D(A, B) ≤ dak ,bh − dak ,bk − dah ,bh
1.13. SPAZI METRICI RESISTIVI
57
Per la diseguaglianza triangolare dak ,bh ≤ dak ,ah + dah ,bh da cui
∆D(A, B) ≤ dak ,ah − dak ,bk
ovvero, ricordando che ak = k+1, ah = h + 1 e bk = 1
∆D(A, B) ≤ dk+1,h+1 − dk+1,1
La variazione della sommatoria i<j dai ,aj che rappresenta la dispersione
tra i server di RWALK e` dovuta alla variazione delle distanze tra il server h
che viene mosso e tutti gli altri server, ossia
k
∆
[di+1,1 − di+1,h+1 ]
dai ,aj =
i<j
i=1
i=h
e quindi la differenza di potenziale ∆Φt relativa alla seconda fase e` limitata
superiormente da
k
[di+1,1 − di+1,h+1 ] + k[dk+1,h+1 − dk+1,1 ]
∆Φt ≤
i=1
i=h
e siccome CRWALK (rt ) = dh+1,1
∆Φt + CRWALK (rt )
k
[di+1,1 − di+1,h+1 ] + k[dk+1,h+1 − dk+1,1 ] + dh+1,1
≤
i=1
i=h
k
[di+1,1 − di+1,h+1 ] + k[dk+1,h+1 − dk+1,1 ]
=
i=1
k
[di+1,1 − di+1,h+1 + dk+1,h+1 − dk+1,1 ]
=
i=1
Indicando per brevit`a l’i-esimo addendo della sommatoria con
e(i, h) = di+1,1 − di+1,h+1 + dk+1,h+1 − dk+1,1
possiamo scrivere la disuguaglianza come
k
∆Φt + CRWALK (rt ) ≤
e(i, h)
i=1
58
CAPITOLO 1. ALGORITMI ON-LINE
Sia C = [Ci,j ] la matrice (k+1) × (k+1) delle conduttanze dirette relativa
all’insieme di vertici 1, . . . , k, k+1. Prendendo i valori attesi di entrambi i
membri della disequazione precedente si ottiene
k
E[∆Φt + CRWALK (rt )] ≤ E[
e(i, h)]
i=1
k
k
Pr[h → 1]
=
h=1
k
=
h=1
=
k
j=1
e(i, h)
i=1
k
Ch+1,1
e(i, h)
k
j=1 Cj+1,1 i=1
k
k
1
Cj+1,1
e(i, h)
Ch+1,1
h=1
i=1
dove Ch+1,1 e` la conduttanza diretta tra il vertice ah = h + 1 (dove si trova
il server mosso da RWALK) e il vertice rt = 1.
Se dimostriamo che
k
k
e(i, h) = 0
Ch+1,1
(1.14)
i=1
h=1
possiamo concludere che
E[∆Φt + CRWALK (rt )] ≤ 0
Per dimostrare l’equazione 1.14 dobbiamo richiamare alcuni fatti sui circuiti elettrici che ci diano delle informazioni sui coefficienti Ch+1,1 .
Sia D la sottomatrice (k+1) × (k+1) della matrice delle distanze indotta
˜ la matrice
sull’insieme 1, . . . , k, k+1 (che sappiamo essere resistiva). Sia D
˜ k la sottomatrice k × k di D
˜
calcolata al passo 1 della Procedura 1.13.3 e D
˜
˜
ottenuta eliminando l’ultima riga e l’ultima colonna. Sia C = [Ci,j ] =
˜ k )−1 la matrice inversa calcolata al passo 2.
(D
˜k = I
Siccome C˜ · D
k
d˜i+1,j C˜j,1 = 0
j=1
per ogni i = 1, . . . , k − 1. Sommando su i = 1, . . . , k − 1 otteniamo
k−1 k
i=1 j=1
d˜i+1,j C˜j,1 = 0
(1.15)
1.13. SPAZI METRICI RESISTIVI
59
Per il passo 3 della Procedura 1.13.3 abbiamo
C˜j,1 = −Cj,1
per ogni j = 2, . . . , k e, usando l’equazione usata al passo 4
k+1
C˜1,1 =
Cj,1
j=2
e quindi sostituendo nell’equazione 1.15 otteniamo

k−1
k
d˜i+1,j Cj,1 +
−
i=1
k+1
j=2

d˜i+1,1 Cj,1  = 0
j=2
che con la sostituzione j = h + 1 diventa
k−1
k−1
−
i=1
d˜i+1,h+1 Ch+1,1 +
k
d˜i+1,1 Ch+1,1 = 0
h=1
h=1
Siccome d˜i+1,k+1 = (dk+1,i+1 + dk+1,k+1 − di+1,k+1 )/2 = 0 possiamo
estendere fino a k la prima sommatoria interna ottenendo
k−1 k
(d˜i+1,1 − d˜i+1,h+1 )Ch+1,1 = 0
i=1 h=1
Il termine tra parentesi e`
d˜i+1,1 − d˜i+1,h+1 = (dk+1,i+1 + dk+1,1 − di+1,1 )/2
−(dk+1,i+1 + dk+1,h+1 − di+1,h+1 )/2
= (dk+1,1 − di+1,1 − dk+1,h+1 + di+1,h+1 )/2
= −e(i, h)/2
Possiamo infine provare l’equazione 1.14 nel modo seguente
k
k
Ch+1,1
h=1
k
k
e(i, h) =
i=1
e(i, h)Ch+1,1
i=1 h=1
k−1 k
=
e(i, h)Ch+1,1
i=1 h=1
k−1 k
= −2
(d˜i+1,1 − d˜i+1,h+1 )Ch+1,1
i=1 h=1
= 0
60
CAPITOLO 1. ALGORITMI ON-LINE
dove la restrizione soltanto fino a k − 1 della prima sommatoria e` dovuta al
fatto che e(k, h) = dk+1,1 − dk+1,h+1 + dk+1,h+1 − dk+1,1 = 0.
Dunque per la seconda fase vale la disuguaglianza
E[∆Φt + CRWALK (rt )] ≤ 0
Mettendo assieme i risultati ottenuti per le due fasi possiamo concludere che
E[∆Φt + CRWALK (rt ) − kCB (rt )] ≤ 0
e quindi il teorema e` dimostrato ed RWALK e` k competitivo su ogni metrica
resistiva.
1.14
Algoritmo della funzione lavoro
In questa sezione descriveremo l’algoritmo W ORK per il problema dei k-server
e dimostreremo che esso e` (2k − 1)-competitivo. L’algoritmo e` stato proposto
da Chrobak e Larmore [22] che per`o riuscirono a dimostrare soltanto che esso e`
2-competitivo per k = 2. La prima dimostrazione della (2k − 1)-competitivit`a
e` dovuta a Koutsoupias e Papadimitriou [30]. Prima di questo risultato non si
conosceva nessun algoritmo con un rapporto di competitivit`a polinomiale in k per
il problema dei k server in uno spazio metrico arbitrario. Si congettura che W ORK
sia in realt`a k-competitivo ma nessuno e` ancora riuscito a dimostrarlo.
Invece della dimostrazione originale di Koutsoupias e Papadimitriou [30] deriveremo la (2k − 1)-competitivit`a di W ORK da un risultato pi`u generale dimostrato
da Koutsoupias in [31] e la cui dimostrazione risulta pi`u semplice e intuitiva.
Koutsoupias in [31] confronta il costo dell’algoritmo W ORK per soddisfare
la sequenza di richieste ρ utilizzando k server con il costo dell’algoritmo offline ottimo O PT che per soddisfare la medesima sequenza di richieste utilizza un
numero h di server non necessariamente uguale a k.
Dovendo considerare algoritmi che utilizzano un numero h di server diverso
da k annoteremo il nome A dell’algoritmo con un apice che indica il numero di
server usati e scriveremo quindi Ah per indicare l’algoritmo A con h server. Una
notazione analoga Ah = a1 , a2 , . . . , ah la useremo per denotare una configurazione di h server. Useremo anche ah , dove a e` un singolo punto dello spazio metrico,
per indicare la configurazione Ah = a, a, . . . , a di h server tutti nel punto a.
1.14. ALGORITMO DELLA FUNZIONE LAVORO
61
Per non appesantire troppo la notazione continueremo ad usare A ed A per
indicare un algoritmo e una configurazione con esattamente k server.
Koutsoupias in [31] confronta il costo CW ORK (ρ) dell’algoritmo W ORK che
soddisfa la sequenza di richieste ρ utilizzando k server con il costo CO PTh (ρ)
dell’algoritmo off-line ottimo O PTh che per soddisfare la medesima sequenza di
richieste utilizza un numero h di server non necessariamente uguale a k. Precisamente dimostreremo che per ogni h (anche h > k)
CW ORK (ρ) ≤ kCO PTh (ρ) + (h − 1)CO PT (ρ) + c
(1.16)
dove c e` una costante che tiene conto delle possibili diverse configurazione iniziali
degli algoritmi che stiamo comparando.
Per dimostrare la disequazione 1.16 sar`a quindi sufficiente dimostrare la
CW ORK (ρ) ≤ kCO PTh (ρ) + (h − 1)CO PT (ρ)
(1.17)
nell’ipotesi che tutti i server di tutti gli algoritmi coinvolti partano da un punto
iniziale comune r0 .
La disuguaglianza 1.16 e` un risultato pi`u generale della (2k − 1)-competitivit`a
in quanto, ponendo h = k si ottiene
CW ORK (ρ) ≤ (2k − 1)CO PT (ρ) + c
1.14.1
La funzione lavoro
Consideriamo l’algoritmo off-line ottimo O PT che risponde ad una sequenza di
richieste ρ. Dopo aver servito le prime t richieste i suoi k server si troveranno
in una certa configurazione Bt . Il costo per servire ρ si pu`o allora suddividere in
due parti: il costo per servire le richieste r1 , . . . , rt partendo dalla configurazione
iniziale B0 = r0k e terminando nella configurazione Bt ed il costo per servire la
sequenza rt+1 , . . . , rn a partire dalla configurazione Bt . Un algoritmo on-line A
che conosca l’algoritmo O PT non conosce la configurazione Bt (in quanto essa
pu`o dipendere dalle richieste successive che non sono note ad A) ma e` in grado,
per qualsiasi configurazione X di k server, di calcolare il costo ottimo per servire
le richieste r1 , . . . , rt a partire dalla configurazione iniziale A0 = B0 = r0k dei suoi
server e finire con i server nella configurazione X. Questo giustifica la seguente
definizione di funzione lavoro.
Definizione 1.14.1 (Funzione lavoro) Sia A0 = r0k la configurazione iniziale dei
server nello spazio metrico considerato e sia ρ = r1 , r2 , . . . , rn la sequenza di
62
CAPITOLO 1. ALGORITMI ON-LINE
richieste. Per ogni configurazione X = x1 , x2 , . . . , xk di k server definiamo la
funzione lavoro wt (X) al tempo t come il minimo costo per servire off-line le
prime t richieste partendo dalla configurazione iniziale A0 e terminando con i
server nella configurazione X.
Osserviamo che CO PT (ρ) = wn (Bn ) dove Bn e` la configurazione finale a
cui arriva l’algoritmo off-line ottimo O PT partendo dalla configurazione iniziale
B0 = r0k e dopo aver processato tutte la sequenza ρ.
Una conseguenza immediata della definizione di funzione lavoro e` che
k
w0 (X) = D(B0 , X) =
d(r0 , xi )
i=1
dove D(B0 , X) e` la distanza tra le due configurazioni B0 = r0k ed X. In generale
la distanza fra due configurazioni generiche A e B e` il minimo costo per spostare
i k server dalla configurazione A alla configurazione B ed e` definita come
k
D(A, B) = min
π
d(aπ(i) , bi )
i=1
dove il minimo e` calcolato su tutte le permutazioni π degli elementi della configurazione A = a1 , a2 , . . . , ak . Naturalmente se A = r0k le permutazioni di A sono
tutte uguali e la distanza si riduce a D(A, B) = ki=1 d(r0 , bi ).
Per t > 0, l’algoritmo off-line ottimo O PT per servire la richiesta rt e terminare nella configurazione X deve comunque passare per una configurazione Y tale
che rt ∈ Y (anche se rt ∈ X).4 Avremo quindi
wt (X) =
min {wt−1 (Z) + D(Z, Y ) + D(Y, X)}
Z,Y :rt ∈Y
Per la minimalit`a di wt−1 (Y ) possiamo limitarci al caso Z = Y e quindi
wt (X) = min {wt−1 (Y ) + D(Y, X)}
Y :rt ∈Y
In altre parole, nella ricerca del minimo, consideriamo soltanto le configurazioni
Y in cui uno dei server si trova gi`a nella posizione giusta per servire la successiva
richiesta rt .
Il lemma seguente dice che, non solo possiamo limitarci alle configurazioni Y
tali che rt ∈ Y , ma possiamo addirittura limitarci a quelle configurazioni Y =
X − x + rt che differiscono da X soltanto per la posizione di un solo server5 .
4
Se A = a1 , a2 , . . . , ah e` una configurazione di h server e x e` un punto dello spazio metrico la
notazione x ∈ A significa che esiste almeno un server i in posizione ai = x.
5
Quando x ∈ X usiamo la notazione X − x + y per indicare la configurazione ottenuta da X
spostando in posizione y uno dei server che si trovavano in posizione x.
1.14. ALGORITMO DELLA FUNZIONE LAVORO
63
Lemma 1.14.2 Per ogni t > 0 e ogni X
wt (X) = min{wt−1 (X − x + rt ) + d(rt , x)}
x∈X
Dimostrazione. Dimostreremo che valgono entrambe le diseguaglianze
wt (X) ≤ min{wt−1 (X − x + rt ) + d(rt , x)}
x∈X
e
wt (X) ≥ min{wt−1 (X − x + rt ) + d(rt , x)}
x∈X
Per la prima, abbiamo D(X, X − x + rt ) = d(rt , x) e quindi
wt (X) =
min {wt−1 (Y ) + D(Y, X)}
Y :rt ∈Y
≤ min{wt−1 (X − x + rt ) + d(rt , x)}
x∈X
Per la seconda, sia Ymin una configurazione per cui wt (X) = wt−1 (Ymin ) +
D(Ymin , X) e sia x l’elemento di X abbinato a rt nel calcolo di D(Ymin , X).
Sia Y = X − x + rt . Allora
wt (X) =
=
≥
≥
wt−1 (Ymin ) + D(Ymin , X)
wt−1 (Ymin ) + D(Ymin , Y ) + d(rt , x)
wt−1 (Y ) + d(rt , x)
min{wt−1 (X − x + rt ) + d(rt , x)}
x∈X
e dunque e` vera anche la seconda diseguaglianza.
Un’altra importante propriet`a della funzione lavoro e` la quasi-convessit`a. Per
dimostrarla ci sar`a comoda una rappresentazione grafica del modo in cui un algoritmo serve una sequenza di richieste. Chiameremo traccia una tale rappresentazione grafica. Come illustrato dalla Figura 1.9, la traccia e` un grafo i cui nodi
sono le posizioni iniziali a1 , a2 , . . . , ak dei server, le posizioni r1 , r2 , . . . , rn delle
richieste e le posizioni finali x1 , x2 , . . . , xk dei server. Gli archi rappresentano i
movimenti dei server.
Con abuso di linguaggio chiameremo traccia di wt (X) la traccia di un algoritmo off-line ottimo che, con costo wt (X), serve le prime t richieste partendo dalla
configurazione iniziale A0 e terminando con i server nella configurazione X.
La propriet`a di quasi convessit`a della funzione lavoro e` espressa dal seguente
lemma.
64
CAPITOLO 1. ALGORITMI ON-LINE
a3
x3
r2
r3
r4
r7
r9
a2
x2
r1
r5
r6
r8
r10
a1
x1
Figura 1.9: La traccia dell’esecuzione di un algoritmo che processa la sequenza di richieste ρ = r1 , r2 , . . . , r10 utilizzando 3 server che partono dalle posizioni iniziali a1 , a2 , a3 e terminano nelle posizioni finali x1 , x2 , x3 . Le posizioni
a1 , a2 , a3 , r1 , r2 , . . . , r10 , x1 , x2 , x3 non necessariamente sono distinte e quindi alcuni degli archi rappresentano spostamenti nulli. In ogni caso il costo pagato
dall’algoritmo e` la somma delle lunghezze degli spostamenti rappresentati dagli
archi.
Lemma 1.14.3 (Quasi-convessit`a) Siano X h e Y k due configurazioni qualsiasi
rispettivamente di h e k server con h ≤ k e siano wt (X h ) e wt (Y k ) i valori
delle funzioni lavoro relative alle due configurazioni iniziali Ah e B k . Assumiamo
inoltre che le configurazioni iniziali Ah e B k abbiano le posizioni dei primi h
server in comune, ossia ai = bi per i = 1, . . . , h.
Per ogni punto x ∈ X h esiste un punto y ∈ Y k tale che
wt (X h ) + wt (Y k ) ≥ wt (X h − x + y) + wt (Y k − y + x)
Dimostrazione. L’idea della dimostrazione e` quella di usare tutti e soli gli archi
delle tracce di wt (X h ) e wt (Y k ) per costruire le tracce di due algoritmi Ah e B k
che partono rispettivamente dalle configurazioni Ah e B k , entrambi servono le
richieste r1 , . . . , rt e terminano rispettivamente nelle configurazioni X h − x + y
e Y k − y + x per un y opportuno. Siccome vengono usati gli stessi archi avremo
che la somma dei costi CAh e CB k pagati dai due algoritmi e` uguale a wt (X h ) +
wt (Y k ) e quindi
wt (X h ) + wt (Y k ) = CAh + CB k ≥ wt (X h − x + y) + wt (Y k − y + x)
Per costruire le tracce di Ah e B k cominciamo con il riunire in un unico grafo
le tracce di wt (X h ) e wt (Y k ) identificando in uno stesso vertice i punti di partenza
coincidenti ai = bi per i = 1, . . . , h.
In Figura 1.10 e` rappresentata la riunione delle tracce di wt (X h ) e wt (Y k ) per
h = 2 e k = 3, con punti di partenza dei server a1 = b1 , a2 = b2 e b3 e punti
1.14. ALGORITMO DELLA FUNZIONE LAVORO
65
y3
b3
r2
a2 =b2
a1 =b1
r1
r3
r4
r7
r5
r6
x2
r9
r8
y2
r10
x1
y1
Figura 1.10: La riunione delle tracce di wt (X h ) (rosso) e wt (Y k ) (nero). Nell’esempio h = 2 e k = 3, i punti di partenza dei server sono a1 = b1 , a2 = b2 e b3
mentre i punti di arrivo sono x1 , x2 e y1 , y2 , y3 .
di arrivo x1 , x2 e y1 , y2 , y3 . Per mantenere il ricordo della provenienza degli archi
abbiamo colorato in rosso gli archi provenienti dalla traccia di wt (X h ) e in nero
quelli provenienti da wt (Y k ).
Siccome ogni richiesta viene servita da un solo server sia in wt (X h ) che in
wt (Y k ), nella riunione delle due tracce ogni vertice rj ha esattamente due archi
entranti, uno rosso proveniente da wt (X h ) ed uno nero proveniente da wt (Y k ).
Il percorso di un server di wt (X h ) inizia in un vertice ai e termina nel vertice
xi e il percorso di un server di wt (Y k ) inizia in un vertice bi e termina nel vertice
yi . Quindi ogni vertice rj ha anche esattamente due archi uscenti, uno rosso ed
uno nero. Inoltre anche i vertici ai = bi per i = 1, . . . , h hanno esattamente
due archi uscenti, uno rosso e uno nero, mentre i vertici bi per i = h + 1, . . . , k
hanno soltanto un arco uscente nero. Infine i vertici x1 , . . . , xh hanno un solo arco
entrante rosso e i vertici y1 , . . . , yh hanno un solo arco entrante nero.
Sia quindi x ∈ X h e immaginiamo di muoverci sul grafo riunione delle due
tracce nel modo seguente: Partiamo del vertice v0 = x e percorriamo all’indietro
l’unico arco rosso che entra in x arrivando in un vertice di tipo v1 = ri1 o v1 =
ai1 = bi1 . In entrambi i casi abbiamo un solo arco nero uscente da v1 ; percorriamo
in avanti tale arco nero arrivando ad un vertice di tipo v2 = rj2 o v2 = yj2 . Se ci
troviamo in un vertice v2 = yj2 ci fermiamo e poniamo y = yj2 ∈ Y k . Se invece
ci troviamo in un vertice v2 = rj2 possiamo ripetere l’operazione di percorrere un
arco rosso all’indietro e quindi un arco nero in avanti.
Siccome ogni vertice di tipo rj ha esattamente un arco rosso entrante che,
percorso all’indietro, conduce ad un vertice ri o ai = bi da cui parte un solo arco
nero, il procedimento risulta deterministico e pu`o terminare soltanto quando si
arriva ad un vertice vm = yjm nel qual caso ci fermiamo e prendiamo y = yjm ∈
Y k.
66
CAPITOLO 1. ALGORITMI ON-LINE
E` facile vedere che questo procedimento deve terminare poich´e non si ripassa
mai per un arco gi`a attraversato e quindi non ci possono essere cicli. Infatti,
supponiamo per assurdo che si ripassi per uno stesso arco e consideriamo il primo
arco vt vt+1 percorso per la seconda volta.
Se vt vt+1 e` rosso, e quindi e` percorso a ritroso, esso non pu`o essere v0 v1 perch´e
v0 = x che non ha archi neri entranti e quindi non e` possibile ritornare in x.
Quindi t > 0 e vt vt+1 e` preceduto da un arco nero vt−1 vt . Siccome in vt entra
un solo arco nero esso deve essere lo stesso sia la prima che la seconda volta che
percorriamo vt vt+1 il che contraddice il fatto che vt vt+1 sia il primo arco percorso
due volte.
Se vt vt+1 e` nero, e quindi percorso in avanti, esso non pu`o uscire da un vertice
del tipo vt = bi per qualche i = h + 1, . . . , k in quanto non ci sono archi rossi
uscenti da tali vertici e quindi non e` possibile raggiungerli percorrendo un arco
rosso all’indietro. Dunque vt vt+1 esce da un vertice del tipo vt = rjt o vt = ait =
bit . In entrambi i casi abbiamo un solo arco rosso uscente da vt e quindi anche
l’arco rosso precedente deve essere lo stesso sia la prima che la seconda volta che
percorriamo vt vt+1 il che contraddice il fatto che vt vt+1 sia il primo arco percorso
due volte.
Dunque il percorso che costruiamo con questa procedura e` unico e termina
sicuramente in un vertice y ∈ Y k .
Nella Figura 1.11 sono evidenziati i due percorsi che si ottengono partendo
rispettivamente dai vertici x = x1 e x = x2 .
y3
b3
r2
a2 =b2
a1 =b1
r1
r3
r4
r7
r5
r6
x2
r9
r8
y2
r10
x1
y1
Figura 1.11: I percorsi alternanti che partono rispettivamente da x = x1 e x = x2
sul grafo di Figura 1.10. Il percorso che parte da x = x1 e` indicato dalle frecce
blu e il percorso che parte da x = x2 e` indicato dalle frecce verdi. Il percorso che
parte da x = x1 termina in y = y2 e quello che parte da x = x2 termina in y = y3 .
A questo punto per costruire le tracce di Ah e B k ci basta scambiare i colori
degli archi del percorso alternante. In Figura 1.12 si vede il risultato di questa
operazione rispetto al percorso alternante che parte da x = x1 .
1.14. ALGORITMO DELLA FUNZIONE LAVORO
67
y3
b3
r2
a2 =b2
a1 =b1
r1
r3
r4
r7
r5
r6
x2
r9
r8
y2
r10
x1
y1
Figura 1.12: Le tracce dei due algoritmi Ah (in rosso) e B k (in nero) ottenute
scambiando i colori degli archi del cammino alternante che parte da x = x2 e
termina in y = y2 .
Scambiando i colori degli archi del cammino alternante non cambia il numero
e il tipo degli archi uscenti ed entranti in ciascun vertice, tranne il vertice finale
x = xi ed il vertice finale y = yj i cui unici archi entranti cambiano colore.
Dunque nel grafo ottenuto vi sono h cammini rossi distinti che partono dai
vertici della configurazione iniziale A = a1 , . . . , ah e terminano nei vertici della
configurazione finale X − x + y visitando una e una sola volta ciascun vertice ri ,
e questa e` la traccia dell’algoritmo Ah . Gli archi neri invece formano k cammini
distinti che partono dai vertici della configurazione iniziale B = b1 , . . . , bk e terminano nei vertici della configurazione finale Y − y + x visitando una e una sola
volta ciascun vertice ri , e questa e` la traccia dell’algoritmo B k .
Osservazione 4 Per dimostrare il Lemma 1.14.3 della quasi convessit`a non abbiamo usato la disuguaglianza triangolare. Dunque esso vale anche sui vertici di
un qualsiasi grafo pesato sugli archi.
Possiamo illustrare il lemma di quasi convessit`a mediante un gioco su di un
grafo pesato sugli archi. Supponiamo che una mossa del gioco consista nel muovere una pedina da un vertice ad un altro vertice adiacente del grafo e supponiamo
che il gioco si svolga tra il giocatore Bruno che rimane fermo nelle sue posizioni
e due avversari Vittorio e Roberto che cercano di occupare con le loro pedine le
posizioni di Bruno. Bruno ha k pedine poste nei vertici b1 , . . . , bk , Vittorio ha pure k pedine poste nei vertici y1 , . . . , yk mentre Roberto ha soltanto h ≤ k pedine
poste nei vertici x1 , . . . , xh .
Lo scopo di Vittorio e` quello di occupare tutte le k posizioni di Bruno spostando le sue pedine con il minimo costo possibile mentre Roberto si accontenta
di occupare le prime h posizioni di Bruno pagando il minimo costo possibile.
68
CAPITOLO 1. ALGORITMI ON-LINE
Supponiamo che i due avversari vogliano coalizzarsi in modo da rendere minimo il costo totale. Il lemma di quasi periodicit`a dice che per ogni pedina r di
Roberto esiste una pedina v di Vittorio tale che se i due avversari si scambiano le
due pedine il nuovo costo totale risulta minore o uguale al precedente.
1.14.2
L’algoritmo W ORK della funzione lavoro
Sia At−1 la configurazione a cui arriva un algoritmo on-line A dopo aver servito
la sequenza di richieste r1 , . . . , rt−1 partendo dalla configurazione iniziale A0 .
Probabilmente la scelta pi`u naturale per A nel servire la successiva richiesta rt
e` l’algoritmo goloso G REEDY, il quale muove i server in una configurazione At
con rt ∈ At che minimizza la distanza D(At−1 , At ). Purtroppo, come sappiamo,
l’algoritmo G REEDY non e` competitivo. Dal lato opposto delle possibilit`a vi e`
l’algoritmo retrospettivo che muove i server in una configurazione At con rt ∈ At
che minimizza wt (At ). L’idea e` che un algoritmo off-line che abbia i server in
posizione At e` il migliore possibile fino a quel momento. L’algoritmo W ORK
della funzione lavoro che andiamo a descrivere usa una combinazione di tali due
strategie e quindi sta in mezzo tra tali due estremi.
Definizione 1.14.4 (Algoritmo W ORK) L’algoritmo W ORK risponde alla richiesta rt muovendo i server dalla configurazione At−1 in cui si trovano al momento
della richiesta a quella configurazione At tale che rt ∈ At e che minimizza la
somma
wt (At ) + D(At , At−1 )
Osserviamo che wt (At ) = wt−1 (At ) (dato che rt ∈ At ) e quindi
min {wt (At ) + D(At , At−1 )} = wt (At−1 )
At :rt ∈At
Per il Lemma 1.14.2, At = At−1 − xt + rt dove xt e` quella posizione di un server
nella configurazione At−1 che minimizza la quantit`a
wt−1 (At−1 − xt + rt ) + d(xt , rt )
Dunque il costo pagato da W ORK per servire la richiesta rt e` CW ORK (rt ) =
d(xt , rt ) dove xt e` la posizione iniziale del server mosso da W ORK per servire la
richiesta rt .
Definiamo il costo aumentato C + (rt ) per servire la richiesta rt nel modo
seguente
C + (rt ) = wt (At ) − wt−1 (At−1 ) + d(xt , rt )
1.14. ALGORITMO DELLA FUNZIONE LAVORO
69
Quindi il costo aumentato C + (ρ) per servire l’intera sequenza ρ di richieste e`
n
C + (ρ) =
C + (rt )
(1.18)
t=1
n
= wn (An ) − w0 (A0 ) +
d(xt , rt )
(1.19)
= wn (An ) − w0 (A0 ) + CW ORK (ρ)
(1.20)
t=1
Se assumiamo che O PT parta dalla stessa configurazione iniziale A0 di W ORK
allora w0 (A0 ) = 0 e wn (An ) ≥ CO PT (ρ) e quindi
C + (ρ) ≥ CW ORK (ρ) + CO PT (ρ)
Se, dopo aver servito rt vogliamo che i server ritornino nella posizione precedente At−1 dovremo spostare indietro il server in rt nella posizione precedente xt
con un costo d(rt , xt ). Vale quindi l’uguaglianza
wt (At−1 ) = wt (At ) + d(rt , xt )
e quindi
C + (rt ) = wt (At−1 ) − wt−1 (At−1 )
≤ max{wt (X) − wt−1 (X)}
X
La precedente disequazione fornisce un limite superiore per il costo aumentato
C + (rt ) che e` indipendente sia dall’algoritmo che dalla posizione dei server.
In particolare se dimostriamo che
n
t=1
max{wt (X) − wt−1 (X)} ≤ kCO PTh (ρ) + hCO PT (ρ)
X
(1.21)
quando tutti i server partono dallo stesso punto iniziale r0 allora rimane dimostrata
anche la disequazione 1.17 e quindi la (2k − 1)-competitivit`a di W ORK.
Per determinare il valore di maxX {wt (X) − wt−1 (X)} ci serve una ulteriore
propriet`a della funzione lavoro: la propriet`a di dualit`a.
Lemma 1.14.5 (Dualit`a) Sia A un minimizzatore di wt−1 (A) − D(rt , A). Allora
A massimizza wt (A) − wt−1 (A).
70
CAPITOLO 1. ALGORITMI ON-LINE
Dimostrazione. Sia A una configurazione tale che
wt−1 (A) − D(rt , A) = min{wt−1 (X) − D(rt , X)}
X
Dobbiamo dimostrare
wt (A) − wt−1 (A) = max{wt (X) − wt−1 (X)}
X
ossia che
wt (B) − wt−1 (B) ≤ wt (A) − wt−1 (A)
per ogni altra configurazione B. Per il Lemma 1.14.2 questo e` equivalente a
min{wt−1 (B − b + rt ) + d(rt , b)} − wt−1 (B)
b∈B
≤ min{wt−1 (A − a + rt ) + d(rt , a)} − wt−1 (A)
a∈A
Ci basta quindi dimostrare che per ogni a ∈ A
min{wt−1 (B − b + rt ) + d(rt , b)} + wt−1 (A)
b∈B
≤ wt−1 (A − a + rt ) + d(rt , a) + wt−1 (B)
(1.22)
Per la minimalit`a di A
wt−1 (A) − D(rt , A) ≤ wt−1 (A − a + b) − D(rt , A − a + b)
ed eliminando i termini comuni tra D(rt , A) e D(rt , A − a + b) si ottiene
wt−1 (A) − d(rt , a) ≤ wt−1 (A − a + b) − d(rt , b)
che e` equivalente a
d(rt , b) + wt−1 (A) ≤ d(rt , a) + wt−1 (A − a + b)
Sommando wt−1 (B − b + rt ) da entrambe le parti e prendendo i minimi rispetto a
b si ottiene
min{wt−1 (B − b + rt ) + d(rt , b)} + wt−1 (A)
b∈B
≤ min{wt−1 (B − b + rt ) + wt−1 (A − a + b)} + d(rt , a)
b∈B
1.14. ALGORITMO DELLA FUNZIONE LAVORO
71
Se quindi dimostriamo la disuguaglianza
min{wt−1 (B − b + rt ) + wt−1 (A − a + b)}
b∈B
≤ wt−1 (A − a + rt ) + wt−1 (B)
(1.23)
a maggior ragione risulter`a vera la diseguaglianza 1.22.
Siccome rt ∈ A − a + rt , per il Lemma 1.14.3 esiste b ∈ B tale che
wt−1 (A − a + rt ) + wt−1 (B) ≥ wt−1 (B − b + rt ) + wt−1 (A − a + b)
e dunque la disuguaglianza 1.23 e` verificata ed il lemma e` dimostrato.
Il Lemma di dualit`a dice che per trovare un A che massimizza wt (A)−wt−1 (A)
basta cercare un A che minimizza wt−1 (A) − D(rt , A). (Attenzione, il lemma
vale in una sola direzione: ogni A che minimizza wt−1 (A) − D(rt , A) massimizza
wt (A) − wt−1 (A) ma non necessariamente e` vero il contrario.)
La Figura 1.13 illustra il Lemma di dualit`a nel caso semplice in cui t = 1 e tutti
i server partono dalla configurazione iniziale r0k . In questo caso la configurazione
A = ak in cui i server sono tutti in un punto a successivo ad r0 sulla semiretta con
origine in r1 e che passa per r0 e` un minimizzatore di w0 (A) − D(r1 , A). Infatti
se B e` una qualsiasi altra configurazione abbiamo che
w0 (B) − D(r1 , B) = D(r0 , B) − D(r1 , B) ≥ −kd(r0 , r1 ) = w0 (A) − D(r1 , A)
e quindi, per il Lemma 1.14.5 di dualit`a, per ogni altra configurazione B abbiamo
w1 (A) − w0 (A) = 2d(r0 , r1 ) ≥ w1 (B) − w0 (B)
Una osservazione importante e` che se A e` un minimizzatore di wt−1 (A) −
D(rt , A) e prendiamo un punto a ∈ A e lo allontaniamo da rt allora la configurazione che otteniamo e` ancora un minimizzatore. Pi`u precisamente vale il seguente
lemma.
Lemma 1.14.6 Sia a ∈ A un punto in cui si trova uno dei server nella configurazione A e sia rt la posizione della richiesta. Se spostiamo tale server in
un punto b a distanza maggiore di a nella direzione rt → a (per cui d(rt , b) =
d(rt , a)+d(a, b)) allora wt−1 (A−a+b)−D(rt , A−a+b) ≤ wt−1 (A)−D(rt , A).
In particolare, se A e` un minimizzatore di wt−1 (A) − D(rt , A) anche A − a + b e`
un minimizzatore.
72
CAPITOLO 1. ALGORITMI ON-LINE
bk
bi
r1
A=ak
r0
b1
Figura 1.13: Illustrazione del Lemma 1.14.5 nel caso semplice in cui t = 1 e tutti
i server partono dalla configurazione iniziale r0k . In questo caso la configurazione
A = ak in cui i server sono tutti in un punto a sulla retta che passa per r0 ed r1 e` sia
un minimizzatore di w0 (A) − D(r1 , A) che un massimizzatore di w1 (A) − w0 (A).
Dimostrazione. Per la minimalit`a di wt−1 (A − a + b) abbiamo
wt−1 (A − a + b) ≤ wt−1 (A) + d(a, b)
= wt−1 (A) + d(rt , b) − d(rt , a)
= wt−1 (A) + D(rt , A − a + b) − D(rt , A)
e quindi
wt−1 (A − a + b) − D(rt , A − a + b) ≤ wt−1 (A) − D(rt , A)
Se A e` un minimizzatore deve valere l’uguaglianza e quindi anche A − a + b e` un
minimizzatore.
Vi sono spazi metrici particolari, che chiameremo simmetrici, in cui ogni punto a ha un antipodo a
¯ tale che d(a, a
¯) = ∆ dove ∆ e` la massima distanza tra due
punti e inoltre d(a, b) + d(b, a
¯) = d(a, a
¯) = ∆ per ogni altro punto b. In questo
caso, per il lemma precedente, se muoviamo tutti i server nel punto r¯t antipodo
di rt allora la configurazione r¯tk in cui tutti i server sono in r¯t e` un minimizzatore
che risulta essere indipendente dalla funzione lavoro in quanto dipende soltanto
dal punto rt della richiesta.
Esempi di spazi metrici simmetrici sono il cerchio, la superficie della sfera e,
con buona approssimazione, la superficie della terra.
Uno spazio metrico V si dice limitato se le distanze tra i punti hanno un valore
massimo δ detto diametro di V .
1.14. ALGORITMO DELLA FUNZIONE LAVORO
73
Ogni spazio metrico V limitato pu`o essere esteso ad uno spazio simmetrico
W aggiungendo un antipodo a
¯ per ogni punto a dello spazio e ponendo d(¯
a, ¯b) =
d(a, b), d(a, a
¯) = ∆ e d(b, a
¯) = ∆ − d(a, b) dove ∆ = 2δ.
E` facile verificare che se V soddisfa la disuguaglianza triangolare anche W la
soddisfa. Infatti, la disuguaglianza triangolare vale banalmente quando tutti e tre
i punti sono in V oppure tutti e tre sono antipodi. Rimane quindi da verificarla
quando uno dei tre punti e` un antipodo (il caso di due antipodi e` simmetrico).
Siano a, b e c tre punti in V . Per la disuguaglianza triangolare d(b, c) ≤
d(a, b) + d(a, c) e quindi
d(a, b) + d(b, c¯) = d(a, b) + ∆ − d(b, c) ≥ ∆ + d(a, b) − d(b, c)
≥ ∆ − d(a, c) = d(a, c¯)
e
d(a, c¯) + d(¯
c, b) = 2∆ − d(a, c) − d(c, b) ≥ ∆ ≥ d(a, b)
Purtroppo non tutti gli spazi metrici sono limitati ma, ai fini della dimostrazione della disequazione 1.17
CW ORK (ρ) ≤ kCO PTh (ρ) + hCO PT (ρ)
non ci serve considerare tutti i punti dello spazio metrico ma soltanto il sottospazio finito costituito dai punti visitati dagli algoritmi W ORK, O PT e O PTh per
servire le richieste ρ, ossia il punto iniziale r0 da cui partono tutti i server e i punti
r1 , r2 , . . . , rn delle richieste. Chiameremo spazio di interesse questo sottospazio
di n + 1 punti.
Siccome uno spazio con un numero finito di punti e` sempre limitato (il diametro ∆ e` semplicemente la massima distanza tra due punti), possiamo sempre simmetrizzare lo spazio di interesse aggiungendo tutti gli antipodi. Noi lavoreremo
quindi nello spazio simmetrico W = {r0 , r1 , . . . , rn , r¯0 , r¯1 , . . . , r¯n }.
Pertanto, la disequazione 1.21
n
t=1
max{wt (X) − wt−1 (X)} ≤ kCO PTh (ρ) + hCO PT (ρ)
X
possiamo riscriverla come
n
t=1
[wt (r¯t k ) − wt−1 (r¯t k )] ≤ kCO PTh (ρ) + hCO PT (ρ)
74
CAPITOLO 1. ALGORITMI ON-LINE
in quanto sappiamo che r¯t k e` un minimizzatore di wt−1 (A) − D(rt , A) e quindi,
per il Lemma 1.14.5 di dualit`a, wt (r¯t k ) − wt−1 (r¯t k ) e` massimo.
L’idea per dimostrare quest’ultima disequazione e` molto semplice: la riscriveremo nella forma
n
n
wt (r¯t k ) ≤
t=1
s=1
ws−1 (r¯s k ) + kCO PTh (ρ) + hCO PT (ρ)
(1.24)
e quindi costruiremo le tracce di n algoritmi At , per t = 1, . . . , n, che partendo
dalla configurazione iniziale r0k servono le richieste r1 , . . . , rt e quindi terminano
nella configurazione r¯t k . Dalla minimalit`a delle wt (r¯t k ) segue
n
n
wt (r¯t k ) ≤
t=1
t=1
CAt
Mostreremo come sia possibile costruire le tracce degli algoritmi At in modo
tale che la somma dei loro costi risulti minore o uguale di quella delle tracce che
compaiono nelle parte destra della disequazione 1.24 da cui
wt (r¯t k ) ≤
t=1
n
n
n
t=1
CAt ≤
s=1
ws−1 (r¯s k ) + kCO PTh (ρ) + hCO PT (ρ)
La procedura O PTh (ρ) deve certamente servire ciascuna richiesta rt con uno
dei suoi h server. Dopo aver servito rt o il server viene riutilizzato per servire una
richiesta successiva oppure non viene pi`u utilizzato. Per ciascuno degli h server
c’`e una sola richiesta rt che e` l’ultima servita. Sia R l’insieme di tali h richieste.
Costruiremo dapprima gli algoritmi At relativi alle richieste rt ∈ R e poi
quelli relativi alle richieste rt ∈ R.
Sia quindi rt ∈ R e sia rs la richiesta successiva servita dal server che ha
servito rt . Costruiamo l’algoritmo At estendendo la traccia di ws−1 (r¯s k ) con k
archi paralleli che congiungono r¯s a r¯t (vedi Figura 1.14). I costi di tali k archi
sono uguali a quelli degli archi che congiungono rt a rs in ciascuna delle k copie
di O PTh (ρ) che abbiamo a disposizione nella parte destra della disuguaglianza
1.24.
Ci rimangono da costruire gli h algoritmi At relativi alle richieste rt ∈ R per
cui rt e` l’ultima richiesta servita da uno degli h server di O PTh (ρ).
Vediamo quali archi ci rimangono a disposizione per costruire le tracce di
questi ultimi h algoritmi.
Sia S l’insieme delle h richieste rs che sono servite per prime da uno degli h
server di O PTh (ρ).
1.14. ALGORITMO DELLA FUNZIONE LAVORO
75
r¯0
r¯n
r¯1
r¯2
r¯3
r¯t
r¯s−1
r¯s
r1
r2
r3
rt
rs−1
rs
r0
rn
Figura 1.14: Esempio della traccia di At costruita estendendo la traccia di
ws−1 (r¯s k ) con k archi paralleli che congiungono r¯s k a r¯t k . Nell’esempio abbiamo
evidenziato in verde il percorso di uno dei k server di ws−1 (r¯s k ) (quello che serve
la richiesta rs−1 ) prolungato con un arco da r¯s k a r¯t k (tratteggiato). In rosso abbiamo evidenziato il percorso di uno degli h server di O PTh (ρ) (quello che serve
la richiesta rt e poi la richiesta rs ). Le linee punteggiate indicano percorsi che
possono servire anche alcune delle richieste intermedie omesse nella figura.
• Da ns=1 ws−1 (r¯s k ) ci rimangono le h tracce delle ws−1 (r¯s k ) per cui rs ∈ S
e` la prima richiesta servita da uno degli h server di O PTh (ρ). Costo totale
maggiore o uguale a rs ∈S kd(r¯s , r0 ).
• Dalle k copie di O PTh (ρ) ci rimangono k copie degli archi che congiungono
r0 alle h richieste rs ∈ S servite per prime da uno degli h server di O PTh (ρ).
Costo totale uguale a rs ∈S kd(rs , r0 ).
• Tutte le h copie di O PT(ρ).
Il costo totale degli archi che ci rimangono a disposizione nei primi due punti
e`
k[d(r¯s , r0 ) + d(rs , r0 )] ≥ kh∆
rs ∈S
Costruiamo quindi le tracce di ciascuno degli h algoritmi At prendendo gli
archi usati per servire le prime t − 1 richieste da una delle h copie di O PT(ρ) che
ci rimangono a disposizione e aggiungendo i k archi necessari a muovere tutti i
server nella posizione r¯t finale. Il costo di questi ultimi archi e` certamente minore
e uguale a k∆ e pu`o essere pagato con i costi degli archi a disposizione nei primi
due punti.
Dunque
n
t=1
n
CAt ≤
t=1
wt−1 (r¯t k ) + kCO PTh (ρ) + hCO PT (ρ)
76
CAPITOLO 1. ALGORITMI ON-LINE
e quindi la disequazione 1.24 e` verificata e W ORK e` (2k − 1)-competitiva.
Dettagli implementativi
L’algoritmo W ORK deve ad ogni passo trovare la configurazione At che minimizza wt (At ) + D(At , At−1 ). Sappiamo che basta calcolare At = At−1 − xt + rt
dove xt e` quella posizione di un server nella configurazione At−1 che minimizza
la quantit`a
wt−1 (At−1 − xt + rt ) + d(xt , rt )
Per calcolare xt l’algoritmo deve calcolare wt (At−1 ); la posizione xt e` quindi la
posizione in At−1 del server utilizzato dall’algoritmo O PT per servire la richiesta
rt .
La situazione e` illustrata dalla figura seguente dove la traccia di W ORK e`
quella in nero mentra la traccia di wt (At−1 ) e` quella in rosso.
A0 =r0k
Ai−1
At−1
Ai
At =At−1 −xt +rt
Dalla figura possiamo osservare che wt (At ) = wt (At−1 ) − d(xt , rt ) e che vi e`
il limite superiore ovvio Lsup = wt−1 (At−1 ) + d(xt , rt ) ≥ wt (At ).
Indichiamo con X0 = r0k , X1 , . . . , Xt = At le configurazioni per cui passa
l’algoritmo O PT per servire le richieste r1 , . . . , rt e terminare nella configurazione
At e indichiamo con y1 = r0 , y2 , . . . , yt le posizioni dei server mossi da O PT per
servire le richieste r1 , . . . , rt . Il costo pagato da O PT e`
t
wt (At ) =
d(ys , rs )
s=1
Il costo parziale is=1 d(ys , rs ) per servire le prime i richieste e` limitato dal
limite inferiore Linf = d(X0 , Xi ). Se Lsup e` un limite superiore per wt (At ) deve
allora valere per ogni i la diseguaglianza Lsup − ts=i+1 d(ys , rs ) ≥ Linf .
Un limite inferiore migliore si pu`o ottenere osservando che ogni richiesta intermedia rs deve essere stata servita da un server. Sia h il server che ha servito rs
e sia xh la sua posizione in Xi . Allora
Ls,h = d(r0 , rs ) + d(rs , xh ) + d(X0 , Xi ) − d(r0 , xh )
1.14. ALGORITMO DELLA FUNZIONE LAVORO
77
e` un limite inferiore per is=1 d(ys , rs ). Siccome non sappiamo quale sia il server
h che serve rs dovremo prendere come limite inferiore
Ls = min Ls,h
1≤h≤k
e siccome per ogni s abbiamo un limite inferiore Ls possiamo prendere il massimo
Linf = max Ls
1≤s≤i−1
78
CAPITOLO 1. ALGORITMI ON-LINE
Capitolo 2
Algoritmi di Approssimazione
2.1
Introduzione
Molti dei problemi di ottimizzazione che vorremmo risolvere sono NP-difficili.
Vi sono diversi modi per affrontare una tale difficolt`a. Per molti problemi ci sono degli algoritmi di ricerca esaustiva che possono essere accelerati con tecniche
opportune. Alcune di queste tecniche sono: divide-and-conquer ed il pi`u raffinato branch-and-bound che permette di eliminare delle intere parti dell’albero di
ricerca aggiornando ad ogni passo un limite per il valore ottimo; la programmazione dinamica che talvolta conduce ad algoritmi pseudo polinomiali; la tecnica
del piano separatore (per problemi di programmazione intera) mediante la quale
si cerca di raffinare il rilassamento in programmazione lineare per ridurre la regione ammissibile all’involucro convesso delle soluzioni intere; la randomizzazione
che pu`o ridurre la complessit`a media dell’algoritmo; ecc.
Invece di cercare la soluzione ottima, possiamo anche decidere di accontentarci di una soluzione sub-ottimale. Quest’ultimo approccio si riferisce a metodi
euristici. La maggior parte di questi metodi usano un qualche tipo di ricerca locale
nello spazio delle soluzioni fornendo una soluzione localmente ottimale.
In realt`a i metodi euristici si possono anche applicare a problemi di complessit`a polinomiale quando gli algoritmi a disposizione non siano abbastanza efficienti. Un algoritmo di complessit`a Θ(n10 ) o anche un algoritmo di complessit`a
lineare Θ(cn) con costante c = 10100 , bench´e sia efficiente dal punto di vista
della complessit`a asintotica, probabilmente non verr`a mai usato a causa della sua
inefficienza.
Il problema con gli algoritmi euristici e` che e` molto difficile confrontarli. Qua79
80
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
le e` il migliore, quale il peggiore? Di norma un algoritmo euristico funziona
meglio di un altro su certe istanze del problema e peggio su certe altre istanze.
Alcuni tipi di analisi che si possono usare per confrontare algoritmi euristici
sono:
Analisi empirica L’euristica viene valutata su un insieme (sperabilmente significativo) di istanze del problema. Naturalmente non vi e` alcuna garanzia
che il comportamento dell’euristica su tali istanze sia “tipico” (ma cosa
significa poi comportamento tipico?).
Analisi del caso medio Si valuta il comportamento dell’euristica nel caso medio in riferimento ad una qualche distribuzione di probabilit`a delle istanze
del problema. La difficolt`a in questo caso e` che e` molto difficile trovare
una distribuzione di probabilit`a che rispecchi esattamente la distribuzione
delle istanze su cui verr`a usato l’algoritmo nella pratica. Inoltre l’analisi
probabilistica risulta spesso molto difficile.
Analisi del caso pessimo Si valuta il comportamento dell’euristica nel caso peggiore possibile. Bench´e questo tipo di analisi possa sembrare eccessivamente pessimistico, esso ci fornisce una garanzia assoluta sul comportamento
dell’euristica. Questo e` dunque il tipo di analisi che noi useremo.
Introduciamo quindi la seguente definizione.
Definizione 2.1.1 Diciamo che un algoritmo euristico per un problema di minimizzazione (massimizzazione) ha rapporto di approssimazione garantito α se esso
ci garantisce di trovare una soluzione di valore al pi`u (almeno) pari ad α volte il
valore di una soluzione ottima.
Naturalmente deve essere α ≥ 1 per problemi di minimizzazione ed α ≤ 1 per
problemi di massimizzazione.
Definizione 2.1.2 Un algoritmo di α-approssimazione e` un algoritmo di complessit`a polinomiale che garantisce un rapporto di approssimazione α.
Prima di affrontare le tecniche di progetto e analisi degli algoritmi di approssimazione e di illustrare alcuni algoritmi di approssimazione particolari, vediamo
alcuni risultati negativi, ossia risultati del tipo
“Non esiste alcun algoritmo di α-approssimazione per nessun valore
di α”
2.2. RISULTATI NEGATIVI
81
che escludono l’approssimabilit`a di alcuni tipi di problemi, oppure del tipo
“Non esiste alcun algoritmo di α-approssimazione per valori di α
minori (maggiori) di una certa costante c”
che ne limitano l’approssimabilit`a.
2.2
Risultati negativi
Per alcuni problemi di ottimizzazione NP-difficili e` possibile dimostrare un limite
al rapporto di approssimazione garantito α raggiungibile con algoritmi polinomiali (assumendo che P = NP).
Una metodologia standard per dimostrare risultati di questo tipo e` dimostrare che l’esistenza di un algoritmo polinomiale di α-approssimazione per un certo problema permette di risolvere in tempo polinomiale qualche problema NPcompleto.
Osserviamo che, bench´e tutti i problemi NP-completi abbiano complessit`a
equivalente in quanto essi sono riducibili uno all’altro in tempo polinomiale, una
tale riduzione non necessariamente preserva anche l’approssimabilit`a. Di conseguenza possiamo suddividere i problemi NP-completi in classi a seconda della loro approssimabilit`a. Come primo esempio consideriamo il problema del
commesso viaggiatore:
“Assegnate delle lunghezze non negative agli archi di un grafo completo trovare un percorso chiuso di lunghezza minima che visita tutti
i vertici una sola volta.”
Per questo problema non esistono algoritmi di α-approssimazione per nessun
α, a meno che P = NP. Infatti, se esistesse un tale algoritmo potremmo decidere
in tempo polinomiale se un grafo G = (V, E) ha un ciclo Hamiltoniano, problema
che sappiamo essere NP-completo.
Per fare questo basta applicare l’algoritmo di approssimazione al grafo completo con vertici V , lunghezza 1 per gli archi che appartengono anche al grafo G e
lunghezza maggiore di α|V | per ogni altro arco. In questo modo un giro nel grafo
completo ha lunghezza |V | se e` costituito soltanto da archi in G, altrimenti la sua
lunghezza e` strettamente maggiore di α|V |. Se l’algoritmo di approssimazione risponde che la lunghezza minima di un giro e` n = |V | tale giro e` un ciclo Hamiltoniano di G. Se l’algoritmo di approssimazione risponde che la lunghezza minima
82
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
di un giro e` n > α|V | allora il valore ottimo m deve essere m ≥ n/α > |V | e
quindi non esiste alcun ciclo Hamiltoniano per G.
Un altro esempio e` il problema dell’impacchettamento (che e` NP-completo):
“Dati n oggetti con pesi x1 , x2 , . . . , xn tutti minori o uguali ad un
certo valore T si chiede di raggrupparli in pacchetti di peso minore o
uguale a T usando il minimo numero possibile di pacchetti.”
Per questo problema non esistono algoritmi di α-approssimazione con α <
Infatti, consideriamo il problema della partizione (che e` pure NP-completo):
3
.
2
“Dati n oggetti con pesi interi x1 , x2 , . . . , xn tutti minori o uguali ad
S e la cui somma e` ni=1 xi = 2S esiste una partizione in due insiemi
tale che la somma dei pesi di ciascuna parte sia esattamente S?”
Questo e` come chiedere: bastano due pacchetti di peso minore od uguale ad S
per raggruppare tutti gli oggetti? Se avessimo un algoritmo di α-approssimazione
con α < 32 per il problema dell’impachettamento potremmo risolvere il problema
della partizione in tempo polinomiale.
Infatti, sia m il valore ottimo ed n il valore calcolato dall’algoritmo. Se α < 23
devono valere le disequazioni m ≤ n ≤ αm < 32 m.
Se l’algoritmo di approssimazione risponde n = 2 deve essere 43 < m ≤ 2
e quindi m = 2 mentre se l’algoritmo di approssimazione risponde n ≥ 3 deve
essere 32 3 = 2 < m e quindi m > 2.
Pi`u in generale, se il problema di decidere se un certo valore intero e` al pi`u k
risulta essere NP-completo, allora per il problema di minimizzare tale valore non
esistono algoritmi di α-approssimazione per α < k+1
a meno che P = NP.
k
Fino al 1992, gli esempi noti di non approssimabilit`a erano ottenuti con ragionamenti semplici come quelli appena visti. Nel 1992, Arora, Lund, Motwani e
Szegedy pubblicarono un articolo [1] (basato su di un lavoro di Arora e Safra [2])
in cui viene data una nuova caratterizzazione dei problemi NP in termini di prove
controllabili probabilisticamente (PCP).
Prima di illustrare questa nuova caratterizzazione richiamiamo la definizione
classica delle classi di complessit`a P ed NP.
2.2.1
Le classi P ed NP
La definizione standard delle classi di problemi P ed NP e` la seguente
2.2. RISULTATI NEGATIVI
83
Definizione 2.2.1 Un problema P appartiene alla classe di complessit`a P se e
solo se e` risolubile in tempo polinomiale su di una macchina di Turing deterministica. Un problema P appartiene alla classe di complessit`a NP se e solo se e`
risolubile in tempo polinomiale su di una macchina di Turing non deterministica.
Consideriamo il caso in cui il problema P sia un problema di decisione, la cui
risposta e` soltanto SI oppure NO. Se indichiamo con L(P) l’insieme di tutti gli
input x (o meglio delle codifiche degli input) per i quali la risposta e` SI possiamo
interpretare il problema di decisione P come il problema di decidere se una certa
stringa x appartiene ad un linguaggio L(P). Abbiamo quindi la seguente
Definizione 2.2.2 Il problema di decisione P e` in NP se e solo se esiste una
macchina di Turing non deterministica che accetta il linguaggio L(P) in tempo
polinomiale.
Questa definizione si pu`o estendere ad altri tipi di problemi utilizzando la seguente
tecnica della riduzione
Lemma 2.2.3 Sia P un problema in NP, M la macchina di Turing che lo risolve
e sia P un altro problema. Se esiste una macchina di Turing M che risolve P
usando la macchina M come sottoprogramma per un numero costante N = O(1)
di volte e tale che per ogni input x di P il numero di passi eseguiti da M (esclusi
quelli eseguiti da M quando viene richiamata) e` polinomiale nella lunghezza
dell’input x allora anche P e` in NP.
Dimostrazione. Sia T (x) il numero polinomiale di passi eseguiti da M su un
input di dimensione x e T (y) il numero polinomiale di passi eseguiti da M su un
input di dimensione y e sia k tale che T (x) = O(xk ) e T (y) = O(y k ).
` la dimenIl numero totale di passi e` Ttot (x) = T (x) + N
i=1 T (yi ) dove yi e
sione dell’input della i-esima chiamata ad M.
Indichiamo con Ti (x) il numero di passi totale effettuati prima della chiamata
i-esima per i = 1, 2, . . . , N e poniamo inoltre TN +1 (x) = Ttot (x).
La costruzione dell’input di dimensione yi per la chiamata i-esima di M
richiede almeno yi passi e quindi yi ≤ Ti (x).
Dunque T (yi ) ≤ T (Ti (x)) = O (Ti (x))k e quindi
Ti+1 (x) ≤ Ti (x) + T (yi ) + T (x)
= Ti (x) + T (Ti (x)) + T (x) = O (Ti (x))k + O(xk )
84
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Dato che T1 (x) ≤ T (x) = O(xk ) abbiamo Ti+1 (x) = O (T1 (x))ik +
O(xk ) = O(x(i+1)k ) e quindi Ttot (x) = TN +1 (x) = O(x(N +1)k ) = O(xO(1) ) e`
polinomiale in x.
Ricordiamo che una macchina di Turing non deterministica accetta un linguaggio L se esiste almeno una successione di scelte non deterministiche che conduce
ad uno stato di accettazione.
Se vogliamo dimostrare che una certa stringa x appartiene al linguaggio L accettato dalla macchina di Turing non deterministica M dobbiamo esibire una successione y di scelte non deterministiche che conduce ad uno stato di accettazione.
Chiamiamo tale successione y una prova di x ∈ L.
Per verificare se y e` una prova di x ∈ L basta simulare l’esecuzione di M con
input x effettuando le scelte non deterministiche specificate in y.
Un verificatore di y e` quindi semplicemente una macchina di Turing deterministica V ottenuta da M aggiungendo un nastro in cui memorizzare la prova y da
usare per rendere deterministiche le scelte di M.
Notiamo che siccome M accetta in tempo polinomiale nella lunghezza dell’input x, essa effettua al pi`u un numero polinomiale di scelte non deterministiche.
Di conseguenza possiamo assumere che la lunghezza di una prova y per x ∈ L sia
pure polinomiale nella lunghezza dell’input x. Pertanto
Osservazione 5 Se la macchina non deterministica M accetta in tempo polinomiale, il verificatore V cos`ı ottenuto e` una macchina deterministica che accetta in
tempo polinomiale.
Un verificatore V e` quindi una macchina di Turing deterministica che, avendo
in ingresso un input x per la macchina non deterministica M ed una prova y di
x ∈ L accetta se e solo se la macchina M accetta x effettuando le scelte non
deterministiche specificate nella prova y.
Facendo ricorso alla tesi di Church (che ogni procedura effettiva pu`o essere
eseguita su una macchina di Turing), noi useremo la definizione di prova e di
verificatore in un modo informale.
Ad esempio se il problema e` quello di decidere se un grafo G e` Hamiltoniano, una prova e` semplicemente un ciclo Hamiltoniano ed un verificatore e` un
algoritmo che dato il grafo (l’input) ed un ciclo (la prova) controlla che esso sia
effettivamente un ciclo Hamiltoniano per il grafo G.
Abbiamo visto (Osservazione 5) che ogni problema di decisione in NP ha un
verificatore in P.
2.2. RISULTATI NEGATIVI
85
Viceversa, supponiamo che per un problema di decisione P esista un verificatore V che richiede tempo polinomiale nella lunghezza dell’input x per controllare
una prova y di x ∈ L(P).
Poich´e V in tempo polinomiale pu`o ispezionare soltanto una parte iniziale di
lunghezza polinomiale del nastro contenente la prova y possiamo assumere che la
prova y abbia lunghezza polinomiale nella lunghezza di x, ossia che |y| ≤ p(|x|)
con p polinomio che dipende soltanto da V.
Possiamo allora costruire una macchina di Turing non deterministica M che
accetta L(P) in tempo polinomiale nel modo seguente: la macchina M genera
non deterministicamente tutte le possibili prove y di lunghezza minore o uguale di
p(|x|) ed usa il verificatore V per decidere se x ∈ L(P) con prova y. La macchina
M accetta L(P) in tempo polinomiale e dunque il problema P e` in NP.
Questo giustifica la seguente caratterizzazione dei problemi NP
Definizione 2.2.4 Un problema P e` in NP se e solo se esiste un verificatore V
che richiede tempo polinomiale nella lunghezza dell’input x per controllare una
prova y di x ∈ L(P).
Un problema P si dice NP-difficile se ogni problema P ∈ NP pu`o essere
ridotto a P. Se il problema NP-difficile P appartiene esso stesso alla classe NP
allora si dice che esso e` NP-completo.
Dalla definizione segue immediatamente che tutti i problemi NP-completi sono equivalenti tra loro in quanto riducibili uno all’altro. Per dimostrare P = NP
basterebbe quindi trovare un algoritmo polinomiale per un qualsiasi problema
NP-completo.
L’esistenza di problemi NP-completi e` assicurata dal seguente teorema di
Cook.
Teorema 2.2.5 (Teorema di Cook) Il problema 3Sat e` NP-completo.
L’input del problema 3Sat e` una formula logica costituita dalla congiunzione di
clausole, ciascuna delle quali e` la disgiunzione di tre letterali che a loro volta sono
o una variabile logica x o la sua negazione x. Ad esempio:
(x1 ∨ x2 ∨ x3 ) ∧ (x3 ∨ x4 ∨ x2 ) ∧ . . . ∧ (x7 ∨ x1 ∨ x8 )
Il risultato e` SI se esiste una assegnazione di valori booleani alle variabili logiche
tale che la formula risulti vera, e` NO altrimenti.
La dimostrazione del Teorema di Cook (che si pu`o trovare in ogni testo di
computabilit`a) consiste essenzialmente nel mostrare come, data la macchina di
86
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Turing non deterministica M che risolve un problema P ∈ NP ed un input x
per P, sia possibile costruire, in tempo polinomiale nella dimensione di x, una
formula logica FM,x che simula la macchina M sull’input x, nel senso che FM,x
e` soddisfacibile se e solo se M accetta x.
Osserviamo che la complessit`a polinomiale della costruzione dipende soltanto
dalla dimensione di x in quanto la dimensione di M e` una costante e la dimensione
di FM,x e` sicuramente polinomiale nella dimensione di x in quanto essa e` costruita
in tempo polinomiale.
Una volta dimostrato che 3Sat e` NP-completo possiamo usare il Lemma di
riduzione 2.2.3 per dimostrare che altri problemi sono NP-completi oppure soltanto NP-difficili. Questo e` stato fatto per un gran numero di problemi naturali
(che non hanno niente a che fare con le macchine di Turing) per cui oggi si conoscono moltissimi problemi NP-completi ed NP-difficili. Nel prossimo paragrafo
mostreremo una di tali riduzioni.
2.2.2
Riduzione di 3Sat a 3Color
Nel problema 3Color viene dato un grafo non orientato e si chiede se sia possibile
colorarne i vertici con 3 colori distinti in modo tale che vertici adiacenti abbiano
sempre colori diversi. Detto in altro modo si tratta di verificare se il grafo e` tripartito, ossia se i vertici possono essere suddivisi in tre parti in modo tale che nessun
arco connetta due vertici che stanno dalla stessa parte.
Lo stesso problema con 2 soli colori, ossia verificare se un grafo e` bipartito si
pu`o risolvere in tempo lineare con una semplice ricerca in profondit`a.
Il problema della tripartizione e` invece molto pi`u difficile. Dimostreremo infatti che 3Color e` NP-difficile effettuando una riduzione a 3Color del problema
3Sat (che sappiamo essere NP-completo per il teorema di Cook).
Per fare questo dobbiamo mostrare come dato un input per 3Sat (un insieme
di clausole ternarie) sia possibile costruire un grafo G che risulti 3-colorabile se e
solo se la congiunzione di tutte le clausole in input e` soddisfacibile.
Sia dato un input per 3Sat costituito da un insieme finito di clausole ternarie
del tipo c = l1 ∨ l2 ∨ l3 . Costruiamo il grafo G = (V, E) nel modo seguente:
1. Mettiamo in V un vertice per ogni letterale l che compare in qualche clausola e un vertice per ogni clausola c ed infine aggiungiamo due vertici speciali
a e b.
2. Mettiamo in E i seguenti archi:
2.2. RISULTATI NEGATIVI
87
(a) l’arco ab;
(b) i due archi ac e cb per ogni clausola c.
(c) un arco al per ogni letterale l.
(d) l’arco ll per ogni coppia di letterali complementari l = x ed l = x.
3. infine, per ogni clausola c = l1 ∨ l2 ∨ l3 colleghiamo i vertici l1 , l2 , l3 con il
vertice c mediante il seguente sottografo (gadget):
1
l1
3
4
c
l2
2
5
l3
Questo comporta l’aggiunte di 5 nuovi vertici e 10 nuovi archi per ogni
clausola c.
Il grafo completo ha quindi la seguente forma:
l1
l2 =x
c
l3
a
b
l1 =¯
x
c
l2
l3
88
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Figura 2.1: Le 3-colorazioni relative alle altre sette colorazioni possibili di
l1 , l2 , l3 .
dove i vertici l1 , l2 , l3 non necessariamente sono distinti dai vertici l1 , l2 , l3 .
Dobbiamo dimostrare che le clausole sono tutte soddisfacibili se e solo se il
grafo G e` 3-colorabile.
Osserviamo intanto che in ogni 3-colorazione i vertici di un triangolo devono
avere tre colori distinti. In particolare i tre vertici a, b, c devono avere tre colori
distinti. Usiamo i tre colori bianco, verde e rosso e assumiamo, senza perdita
di generalit`a, che in ogni 3-colorazione del grafo G i tre vertici a, b, c abbiano
rispettivamente i colori: a bianco, b rosso e c verde.
Osserviamo inoltre che in ogni possibile 3-colorazione i vertici l1 , l2 , l3 possono assumere soltanto i colori verde o rosso in quanto il vertice adiacente a e`
bianco.
2.2. RISULTATI NEGATIVI
89
In realt`a, data la struttura del gadget, i tre vertici l1 , l2 , l3 possono assumere tutte le possibili combinazioni dei due colori verde e rosso esclusa la combinazione
in cui essi sono tutti e tre rossi.
Infatti, se l1 , l2 , l3 fossero tutti e tre rossi allora i vertici 1 e 2 del gadget dovrebbero essere uno verde ed uno bianco e di conseguenza il vertice 3 dovrebbe
essere rosso. Dunque i vertici 4 e 5 del gadget dovrebbero essere uno verde ed
uno bianco e dunque c non pu`o essere verde.
Le 3-colorazioni relative alle altre sette colorazioni possibili di l1 , l2 , l3 sono
illustrate nella Figura 2.1.
Dunque se il grafo G e` 3-colorabile e interpretiamo il colore verde come VERO
ed il colore rosso come FALSO esiste almeno una assegnazione di valori booleani
ai letterali delle clausole tale che due letterali opposti abbiano valori opposti e in
ogni clausola ci sia almeno un letterale VERO.
Viceversa, se vi e` una assegnazione di valori booleani per cui due letterali
opposti abbiano valori opposti e in ogni clausola ci sia almeno un letterale VERO
allora possiamo costruire una 3-colorazione del grafo G colorando il vertice a
bianco, il vertice b rosso, tutti i vertici c verde e i vertici relativi ai letterali verde o
rosso a seconda che ad essi sia assegnato il valore VERO o FALSO. Infine usiamo
le 7 colorazioni dei gadget appena viste per colorare i nodi interni ai gadget.
Dunque 3Color e` NP-difficile. Possiamo dimostrare anche che 3Color e` NPcompleto osservando che esso pu`o essere risolto con una macchina di Turing
non deterministica che genera non deterministicamente una colorazione qualsiasi
(tempo O(n)) e quindi la verifica (tempo O(m)).
2.2.3
Dimostrazioni “oltre ogni ragionevole dubbio”
Riformuliamo la definizione classica della classe NP in termini di verifica di una
prova:
Definizione 2.2.6 Un linguaggio L ⊆ Σ∗ appartiene alla classe NP se e solo
se esiste una macchina di Turing deterministica VL (verificatore per L) che con
input una istanza x del problema di lunghezza n ed una prova y di lunghezza
polinomiale in n si comporta nel seguente modo:
• Esecuzione: VL termina in tempo polinomiale e risponde ACCETTO oppure
RIFIUTO .
• Completezza perfetta: Se x ∈ L allora esiste almeno una prova y tale che
VL con input (x, y) accetta.
90
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
• Sicurezza perfetta: Se x ∈ L allora VL con input (x, y) rifiuta qualunque
sia la prova y.
Ad esempio, per il problema 3Sat il linguaggio L e` l’insieme di tutte le formule x (congiunzioni di clausole ternarie) che sono soddisfacibili mentre y e` una
assegnazione di valori booleani alle variabili della formula. Il verificatore VL si
limita quindi a calcolare il valore della formula x con l’assegnazione y. Chiaramente se n e` la lunghezza di x la lunghezza di y e` O(n) e il calcolo si pu`o fare in
tempo O(n).
Nella definizione precedente le condizioni di completezza e sicurezza sono
molto restrittive. Con questa definizione una dimostrazione e` molto simile ad una
classica dimostrazione matematica. Non c’`e possibilit`a di errore e una affermazione, quale ad esempio x ∈ L, e` vera se e solo se esiste una prova assolutamente
certa.
Consideriamo ora il concetto di prova che si usa in un tribunale. In questo caso ci si accontenta di una prova “oltre ogni ragionevole dubbio”, ammettendo che
ci possa essere una qualche possibilit`a teorica che l’affermazione da dimostrare
risulti falsa ma tale possibilit`a abbia probabilit`a talmente piccola da risultare assolutamente trascurabile (ad esempio, in teoria, potrebbe esistere una minima probabilit`a che una pistola cada dal cielo, urtando il suolo spari il colpo che uccide la
vittima e poi rimbalzi nella mano del sospettato).
Torniamo nel nostro ambiente computazionale. Supponiamo di accettare di
accontentarci di una prova oltre ogni ragionevole dubbio, ossia con probabilit`a di
errore al pi`u ε. In altre parole noi usiamo la randomizzazione nel nostro procedimento di controllo della prova e ammettiamo che con probabilit`a minore o uguale
di ε possa succedere che viene accettato x ∈ L (sicurezza imperfetta) oppure
venga rifiutato x ∈ L (completezza imperfetta).
Con questa nozione indebolita di dimostrazione (e usando la randomizzazione) noi possiamo risparmiare moltissimo sulle risorse computazionali necessarie
per controllare la prova.
Definiamo ora formalmente le classi di linguaggi decidibili con prove oltre
ogni ragionevole dubbio ma prima dobbiamo definire il concetto di verificatore
probabilistico (ossia il procedimento probabilistico di controllo di tali prove).
Definizione 2.2.7 (Verificatore probabilistico.) Date quattro funzioni , q, r, t sugli interi positivi, un verificatore ( , q, r, t)-ristretto e` una macchina di Turing deterministica V avente accesso ad un generatore casuale di bit e ad una memoria
ad accesso diretto (RAM) in cui e` memorizzata la prova y. Con input x di lunghezza n la macchina V riceve una prova y di lunghezza |y| ≤ (n), genera al
2.2. RISULTATI NEGATIVI
91
pi`u r(n) bit casuali, sulla base di tali bit accede ad al pi`u a q(n) posizioni nella
prova y e, in un tempo totale minore o uguale a t(n), risponde ACCETTO oppure
RIFIUTO .
Se specifichiamo il livello di completezza e di sicurezza per un verificatore
( , q, r, t)-ristretto abbiamo definito completamente una classe di complessit`a:
Definizione 2.2.8 (Classi PCP.) Siano , q, r, t come nella Definizione 2.2.7 precedente e siano c, s due funzioni N → [0, 1] degli interi non negativi nei reali
compresi tra 0 e 1. Allora la classe:





PCP 




lunghezza
randomizzazione
query
tempo
completezza
sicurezza
=
=
=
=
=
=
(n)
r(n)
q(n)
t(n)
c(n)
s(n)










e` la classe di tutti i linguaggi L per i quali esiste un verificatore V probabilistico
( , q, r, t)-ristretto tale che:
• Completezza: Se x ∈ L allora esiste almeno una prova y tale che V con
input (x, y) accetta con probabilit`a maggiore o uguale a c(n).
• Sicurezza: Se x ∈ L allora per ogni prova y il verificatore V con input
(x, y) rifiuta con probabilit`a maggiore o uguale ad s(n).
Le probabilit`a vengono calcolate assumendo che la sequenza degli r(n) bit generati sia scelta casualmente e uniformemente fra tutte le sequenze in {0, 1}r(n) .
Se non vengono specificate c ed s si assume implicitamente che c = 1 (completezza perfetta) ed s = 1/2.1
Per ogni verificatore probabilistico V abbiamo sempre r(n) = O(t(n)) (per
generare r(n) bit casuali occorre almeno tempo proporzionale ad r(n)) e q(n) =
O(t(n)) (per ispezionare q(n) posizioni della prova occorre almeno tempo proporzionale a q(n)).
Possiamo inoltre assumere, senza perdita di generalit`a, che
(n) ≤ q(n)2r(n) = O(t(n)2r(n) )
1
Il valore 1/2 e` stato scelto per convenienza. Qualunque valore s > 0 va altrettanto bene.
Possiamo infatti ripetere l’esecuzione del verificatore per un sufficiente numero di volte t in modo
che la probabilit`a 1 − (1 − s)t di rifiutare almeno una volta diventi maggiore di 1/2.
92
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
altrimenti ci sarebbero alcune posizioni della prova che non vengono mai controllate con nessuna scelta casuale e che quindi sono inutili e possono essere eliminate
accorciando la prova.
Indichiamo con
∞
O(nk )
poly(n) =
k=0
la classe delle funzioni polinomiali e quindi gli algoritmi di complessit`a polinomiale sono quelli per cui t(n) = poly(n).
Quando per un verificatore probabilistico non specifichiamo e t assumiamo
implicitamente che t(n) = poly(n) ed (n) = poly(n). Dunque quando parliamo
di verificatore (r, q)-ristretto intendiamo ( , q, r, t)-ristretto con = poly(n) e
t = poly(n).
La classe PCP(r, q) e` quindi costituita da tutti i problemi per i quali esiste un
verificatore probabilistico (r, q)-ristretto con = poly(n), t = poly(n), c = 1 ed
s = 1/2.
Possiamo osservare che se r(n) = 0 il verificatore probabilistico si riduce ad
uno deterministico e quindi i problemi che appartengono alla classe PCP(0, q) sono quelli per i quali esiste un verificatore deterministico con complessit`a poly(n).
Dalla Definizione 2.2.4 segue la seguente caratterizzazione della classe NP.
Teorema 2.2.9 NP = PCP(0, poly(n))
Ovvero, tenendo conto dei valori convenzionali per , t, c ed s:

NP =




PCP 




lunghezza
randomizzazione
query
tempo
completezza
sicurezza
=
=
=
=
=
=
poly(n)
0
poly(n)
poly(n)
1
1/2










Osserviamo che essendo in questo caso il verificatore deterministico dire che
rifiuta x ∈ L con probabilit`a maggiore di 1/2 e` come dire che rifiuta senz’altro.
Un risultato importante ottenuto in [1] e` che esiste anche un’altra caratterizzazione della classe NP in termini di verificatori (effettivamente) probabilistici e
precisamente
Teorema 2.2.10 (Arora) NP = PCP(log n, 1).
2.2. RISULTATI NEGATIVI
93
Ovvero, tenendo conto dei valori convenzionali per , t, c ed s:

NP =




PCP 




lunghezza
randomizzazione
query
tempo
completezza
sicurezza
=
=
=
=
=
=
poly(n)
O(log(n))
O(1)
poly(n)
1
1/2










In altre parole la classe NP e` costituita dai problemi le cui prove sono controllabili da un verificatore probabilistico che genera un numero di bit logaritmico
nella lunghezza dell’input e sulla base di tali bit sceglie un numero costante di bit
della prova da controllare.
Noi ometteremo la dimostrazione di questo teorema (che e` molto complicata)
e ci limiteremo ad usarlo per dimostrare alcuni risultati di non approssimabilit`a.
Recentemente Irit Dinur [6] ha pubblicato una dimostrazione pi`u semplice del
teorema 2.2.10 basata su un risultato di non approssimabilit`a, ottenuto direttamente, per una generalizzazione del problema 3Color. Anche questa dimostrazione, bench´e molto pi`u intuitiva di quella di Arora, risulta comunque piuttosto
complicata (una ventina di pagine).
2.2.4
Risultati negativi derivati dal Teorema PCP
Consideriamo il seguente problema Max-3Sat: dato un insieme di clausole ternarie trovare una assegnazione di valori booleani alle variabili che massimizza
il numero di clausole verificate. Chiaramente, se sappiamo risolvere Max-3Sat
sappiamo risolvere anche 3Sat e dunque Max-3Sat e` NP-difficile.
Per Max-3Sat vale il seguente
Teorema 2.2.11 Esiste un > 0 tale che nessun algoritmo di approssimazione
per il problema Max-3Sat pu`o avere coefficiente di approssimazione maggiore o
uguale di 1 − (a meno che P = NP).
Dimostrazione. Sia L il linguaggio di un qualsiasi problema di decisione NPcompleto P e sia V il verificatore probabilistico (log n, 1)-ristretto la cui esistenza
e` assicurata dal Teorema 2.2.10.
Osserviamo che il numero di sequenze distinte di bit casuali di lunghezza
O(log n) e` s = 2O(log n) che e` polinomiale in n.
94
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
bi1 , bi2 , . . . , bik−1 , bik
0 0 ... 0
0
0 0 ... 0
1
0 0 ... 1
0
0 0 ... 1
1
...
0 1 ... 0
0
0 1 ... 0
1
0 1 ... 1
0
...
risultato
0
0
1
0
...
1
0
1
...
Figura 2.2: Tavola di verit`a delle risposte di un verificatore (log n, 1)-ristretto in
funzione dei k bit bi1 , bi2 , . . . , bik selezionati. La risposta SI e` rappresentata dal
risultato 1 e la risposta NO e` rappresentata dal risultato 0.
Consideriamo una di queste sequenze. Essa individua nella prova y un numero
costante bi1 , bi2 , . . . , bik di bit da controllare e sulla base di tali bit il verificatore
decide se rispondere ACCETTO oppure RIFIUTO.
La risposta del verificatore in funzione dei k bit bi1 , bi2 , . . . , bik selezionati
pu`o essere rappresentate con una tavola di verit`a del tipo di quella in Figura 2.2
interpretando il risultato ACCETTO con 1 e RIFIUTO con 0.
Possiamo tradurre la tavola di verit`a in una formula logica nelle variabili booleane bi1 , bi2 , . . . , bik in due modi: come disgiunzione di al pi`u 2k congiunzioni di
k letterali: una congiunzione per ogni riga della tavola la cui risposta e` 1.
Ad esempio la terza riga della tavola di Figura 2.2 fornisce la congiunzione
bi1 ∧ bi2 ∧ . . . ∧ bik−1 ∧ bik
Alternativamente, possiamo tradurre la tavola di verit`a come congiunzione di
al pi`u 2k disgiunzioni di k letterali (una disgiunzione per ogni riga con risposta 0).
Ad esempio la quarta riga della tavola di Figura 2.2 fornisce la disgiunzione
bi1 ∨ bi2 ∨ . . . ∨ bik−1 ∨ bik
In questo secondo modo otteniamo una formula per kS AT. Siccome k = O(1)
(e quindi anche 2k = O(1)) quest’ultima formula si pu`o esprimere come una
formula per 3S AT avente un numero costante di clausole e di variabili (bench´e
esponenziale in k). Pi`u precisamente, usando la riduzione classica da S AT a 3S AT,
si ottiene una formula con al pi`u O(k2k ) clausole e variabili.
2.2. RISULTATI NEGATIVI
95
Nella riduzione classica una clausola di k letterali
l1 ∨ l2 ∨ . . . ∨ lk−1 ∨ lk
viene dapprima rappresentata con un albero
yk ∨
yk−1 ∨
k
k
y3 ∨
y2 ∨
1
3
2
introducendo una nuova variabile yi per ogni nodo interno. (La variabile yi rappresenta il valore della sottoclausola rappresentata dal sottoalbero radicato nel
nodo.)
La clausola viene quindi riscritta nella forma equivalente
yk ∧ [yk ⇔ (yk−1 ∨ lk )] ∧ . . . ∧ [y2 ⇔ (l1 ∨ l2 )]
Ciscun congiunto del tipo yk ⇔ (yk−1 ∨ lk ) si scompone nelle congiunzione
delle due implicazioni yk ⇒ (yk−1 ∨ lk ) e (yk−1 ∨ lk ) ⇒ yk . Le implicazioni
A ⇒ B vengono quindi espresse in modo classico come A ∨ B ottenendo:
(yk ∨ yk−1 ∨ lk ) ∧ ((yk−1 ∨ lk ) ∨ yk )
che e` equivalente a
(yk ∨ yk−1 ∨ lk ) ∧ (yk−1 ∨ yk ) ∧ (lk ∨ yk )
In questo modo la clausola iniziale viene trasformata nella congiunzione di clausole con al pi`u tre letterali. Per ottenere tutte clausole ternarie possiamo replicare
alcuni letterali usando l’equivalenza l = l ∨ l.
Sia m = O(1) il numero di clausole ternarie che si ottiene in questo modo.
Se x ∈ L sappiamo che esiste una prova y tale che risultino soddisfatte tutte
le m clausole relative a tutte le s possibili sequenze di bit casuali, in totale ms
clausole.
96
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Se invece x ∈ L allora, per ogni prova y almeno una met`a degli s gruppi di
m clausole relativi alle s possibili sequenze di bit casuali contiene almeno una
clausola che non e` soddisfatta. Questo significa che se x ∈ L di tutte le ms
clausole almeno 12 s non sono soddisfatte.
Supponiamo esista un algoritmo di approssimazione A per Max-3Sat con rap1
e sia CA il valore ottenuto
porto di approssimazione α = 1 − per < 2m
applicando l’algoritmo A all’insieme delle ms clausole ternarie.
Se CA < αms allora CO PT ≤ CA /α < ms e quindi non tutte le clausole sono
soddisfacibili. Di conseguenza possiamo decidere che x ∈ L.
1
1
Se CA ≥ αms > (1 − 2m
)ms allora vi sono meno di 2m
ms = 12 s clausole
non soddisfatte e dunque possiamo decidere che x ∈ L.
Possiamo quindi decidere x ∈ L in tempo polinomiale (in quanto la nostra costruzione pu`o essere fatta in tempo polinomiale). Siccome il problema di
decisione P e` NP-completo questo e` possibile soltanto se P = NP.
Dal teorema precedente discendono un gran numero di risultati negativi. In
particolare il seguente Corollario che afferma la non approssimabilit`a di tutti i
problemi che sono completi nella classe M AX -S NP, introdotta da Papadimitriou e
Yannakakis in [17], e che noi definiremo in seguito.
Corollario 2.2.12 Per ogni problema M AX -S NP completo esiste una costante
tale che non esiste alcun algoritmo di α-approssimazione con α ≥ 1 − , a meno
che P = NP.
Per ora ci limitiamo ad elencare alcuni problemi che appartengono a tale
classe.
Max-2Sat: Dato un insieme di clausole ciascuna delle quali contiene uno o due
letterali, trova una assegnazione che massimizza il numero di clausole verificate.
Max-k Sat: Come Max-2Sat tranne che le clausole possono contenere fino a k
letterali ciascuna.
Max-Cut: Trovare un taglio massimo di un grafo.
Tsp-Euclideo: Problema del commesso viaggiatore in cui le distanze soddisfano
la disuguaglianza triangolare2 .
2
Attenzione, M AX -S NP contiene soltanto problemi di massimizzazione, mentre Tsp e` un problema di minimizzazione. Si sottintende quindi una sua trasformazione preventiva in problema di
massimizzazione. Lasciamo al lettore individuare una tale facile trasformazione
2.2. RISULTATI NEGATIVI
2.2.5
97
Problemi M AX -S NP completi
Consideriamo il problema Sat. Sono date un insieme C di clausole, ciascuna delle
quali e` una disgiunzione di letterali (dove un letterale e` una variabile o la sua
negazione). Vogliamo sapere se vi e` un modo di assegnare alle variabili i valori
booleani VERO e FALSO in modo tale che tutte le clausole risultino vere.
Una clausola e` una disgiunzione l1 ∨ l2 ∨ . . . ∨ lk di letterali e un letterale e` una
variabile x oppure la sua negazione x. Rappresentiamo una assegnazione di valori
alle variabili con un predicato S(x) che esprime il valore di verit`a della variabile
x (dove S e` un simbolo di funzione unaria). Quindi S(x) e` vero se ad x viene
assegnato il valore vero, e` falso altrimenti.
Possiamo allora scrivere la condizione perch´e l’insieme di clausole C sia
soddisfatto dall’assegnazione S(x) come
∀c ∃x (P (c, x) ∧ S(x)) ∨ (N (c, x) ∧ S(x))
dove P (c, x) e` vero se e soltanto se x compare positivamente nella clausola c ed
N (c, x) e` vero se e soltanto se x compare negativamente in c e i due quantificatori spaziano rispettivamente su tutte le clausole c ∈ C e tutte le variabili x che
compaiono in tali clausole.
La soddisfacibilit`a dell’insieme di clausole C e` quindi espressa da
∃S ∀c ∃x (P (c, x) ∧ S(x)) ∨ (N (c, x) ∧ S(x))
ovvero
∃S ∀c ∃x Ψ(c, x, S)
dove Ψ(c, x, S) e` il predicato (P (c, x) ∧ S(x)) ∨ (N (c, x) ∧ S(x)).
Siccome Sat e` NP-completo, ogni problema in NP pu`o essere ridotto a Sat e
quindi espresso con una formula di questo tipo.
Questo giustifica la caratterizzazione della classe N P dovuta a Fagin [8]:
Teorema 2.2.13 (Fagin) I problemi di decisione in NP sono tutti e soli i problemi
di decisione che si possono esprimere con una formula del tipo
∃S ∀c ∃x Ψ(c, x, S)
dove Ψ(c, x, S) e` una formula logica senza quantificatori.
98
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
I problemi esprimibili con una formula logica
∃S ∀c Ψ(c, S)
in cui non compare la quantificazione sui letterali costituisce una sottoclasse di
NP: quella dei problemi SNP (NP-stretti).
Un esempio e` 3Sat in cui ciascuna clausola e` la disgiunzione di tre letterali. In
questo caso Ψ(c, S) e` una lunga congiunzione di asserzioni del tipo
(c ⇔ x1 ∨ x2 ∨ x3 ) ⇒ (S(x1 ) ∨ S(x2 ) ∨ S(x3 ))
una per ogni terna di variabili (x1 , x2 , x3 ) e per ognuno degli otto modi distinti
(negate o non negate) in cui tali tre variabili possono comparire in una clausola c.
La stessa cosa non si pu`o fare per Sat perch´e il numero di letterali di una
clausola non e` limitato. Quindi Sat non e` in SNP.
Invece di richiedere che Ψ(c, S) sia vera per ogni clausola c possiamo chiedere
di massimizzare il numero di clausole c per cui essa e` vera. In questo modo
otteniamo il problema di massimizzazione
max |{c | Ψ(c, S)}|
S
Questo tipo di problemi comprende la classe MAX-SNP definita da Papadimitriou e Yannakakis [17]. In particolare Max-3Sat e` in MAX-SNP.
Papadimitriou e Yannakakis hanno introdotto un tipo particolare di riduzione,
detta L-riduzione (dove L sta per lineare), che preserva l’approssimabilit`a. In particolare, se il problema P si pu`o L-ridurre al problema P ed esiste un algoritmo di
α-approssimazione per P allora esiste anche un algoritmo di γα-approssimazione
per P dove γ e` una costante che dipende dalla riduzione.
Una volta definite le L-riduzioni possiamo definire i problemi MAX-SNP
completi come quei problemi P in MAX-SNP tali che ogni altro problema P
in MAX-SNP si possa L-ridurre a P. Alcuni esempi di problemi MAX-SNP
completi sono Max-3Sat, Max-2Sat (in effetti Max-k Sat per ogni k > 1) e MaxCut. Il fatto che Max-3Sat sia MAX-SNP completo, assieme al Teorema 2.2.11
implica il Corollario 2.2.12.
In Bellare e Sudan [4] si dimostra che, nel Teorema 2.2.11, si pu`o scegliere
1
.
= 74
I problemi di minimizzazione non sono generalmente esprimibili in modo da
essere in MAX-SNP ma possono ugualmente essere MAX-SNP difficili.
Esempi di problemi di minimizzazione MAX-SNP difficili sono
2.3. PROGETTAZIONE DI ALGORITMI DI APPROSSIMAZIONE
99
Tsp con pesi 1 e 2 (ossia d(i, j) ∈ {1, 2} per ogni coppia (i, j)). Per questo problema esiste un algoritmo di 67 -approssimazione dovuto a Papadimitriou e
Yannakakis.
Alberi di Steiner con pesi 1 e 2 Problema degli alberi di Steiner: dato un grafo
connesso e pesato sugli archi ed un sottoinsieme s di vertici trovare il minimo albero che li connette tutti. Nel nostro caso i pesi valgono solo 1 o
2.
Minima copertura di vertici (Mvc). Dato un grafo G = (V, E), una copertura
di vertici e` un sottoinsieme S ⊆ V tale che per ogni arco uv ∈ E si abbia
che o u ∈ S oppure v ∈ S. Il problema richiede di trovare una copertura la
cui somma dei pesi dei vertici sia minima. Se si assume peso unitario per i
vertici si parla di copertura di vertici di cardinalit`a minima (Mcvc).
2.3
Progettazione di algoritmi di approssimazione
Esaminiamo alcune idee chiave per il progetto e l’analisi di algoritmi di approssimazione. Ci riferiremo a problemi di minimizzazione ma le stesse idee si possono
applicare anche a problemi di massimizzazione.
Siccome consideriamo problemi di minimizzazione un algoritmo di α-approssimazione H ha costo CH ≤ α CO PT con α > 1 e dove CO PT e` il costo di una
soluzione ottima.
Mettere in relazione direttamente CH con CO PT pu`o risultare difficile in quanto, per problemi NP-difficili, il costo di una soluzione ottima pu`o essere non ben
definibile. In tal caso pu`o essere utile procedere in due passi: trovare dapprima un limite inferiore Linf per CO PT e quindi mettere in relazione CH con Linf .
Chiaramente, se CH ≤ α Linf a maggior ragione CH ≤ α CO PT .
2.3.1
Riferimento diretto alla soluzione ottima
Un algoritmo di approssimazione la cui soluzione si pu`o porre facilmente in relazione con la soluzione ottima e` l’algoritmo di Christofides [5] per il problema Tsp Euclideo (problema del commesso viaggiatore con disuguaglianza triangolare) che sappiamo essere MAX-SNP-completo. Questo algoritmo e` di 32 approssimazione ed e` il migliore conosciuto per questo problema. L’algoritmo
e` il seguente (vedi Figura 2.3):
100
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
1. Calcola un albero di connessione minimo T del grafo completo G = (V, E).
2. Sia O ⊂ V l’insieme dei vertici di grado dispari in T . Sappiamo che |O| e`
pari.3
3. Calcola un matching perfetto M di costo minimo nel grafo completo G =
(O, E ) indotto da O.
4. Aggiungi a T gli archi di M contando due volte eventuali archi comuni e
ottenendo quindi un multigrafo T ∪ M . Ogni vertice in T ∪ M ha grado pari
e quindi possiamo trovare un percorso Euleriano v1 , v2 , . . . , vk .
5. Segui il percorso Euleriano partendo da v1 e ogni volta che trovi un vertice
vi gi`a incontrato togli tale vertice e i due archi ad esso incidenti e connetti direttamente il vertice precedente con il vertice successivo aggiungendo
l’arco (vi−1 , vi+1 ).
Figura 2.3: Illustrazione dell’algoritmo di Christofides. A sinistra l’albero di
connessione minimo T (con gli archi neri e i vertici dispari rossi) e il matching
minimo M (gli archi verdi). In centro il percorso Euleriano. A destra il ciclo
Hamiltoniano ottenuto partendo dal vertice in basso a sinistra.
Il percorso H cos`ı ottenuto passa una ed una sola volta per tutti i vertici ed e`
quindi un ciclo Hamiltoniano. Dimostriamo che CH ≤ 32 CO PT .
3
Ogni arco contribuisce 2 alla somma dei gradi e quindi la somma dei gradi di tutti i vertici
e` pari. Siccome la somma dei gradi dei vertici di grado pari e` pari anche la somma dei gradi dei
vertici di grado dispari deve essere pari. Infine la somma di |O| numeri dispari e` pari soltanto se
|O| e` pari.
2.3. PROGETTAZIONE DI ALGORITMI DI APPROSSIMAZIONE
101
Sia CT il costo dell’albero di connessione minimo T e CM il costo del matching minimo M . Togliendo un arco da un ciclo Hamiltoniano si ottiene un albero
di connessione. Dunque CT ≤ CO PT .
Dato un ciclo Hamiltoniano H di G possiamo trovare un ciclo Hamiltoniano
per il grafo G indotto da O cortocircuitando i vertici che non stanno in O. Il costo
del ciclo cos`ı ottenuto e` minore o uguale di CH (per la disuguaglianza triangolare).
Dunque CH ≤ CO PT per il ciclo Hamiltoniano ottimo H di G . Prendendo
rispettivamente gli archi di posto pari e di posto dispari in H si ottengono due
matching disgiunti M1 ed M2 per G . Siccome CM1 + CM2 = CH ≤ CO PT ,
almeno uno dei due ha costo minore o uguale di 21 CO PT .
Dunque CM ≤ 12 CO PT per la minimalit`a di M e possiamo concludere che
CH ≤ CT + CM ≤ CO PT + 21 CO PT = 32 CO PT .
Un altro algoritmo approssimato la cui soluzione si pu`o mettere in relazione
direttamente con la soluzione ottima e` l’algoritmo goloso per il problema Msc del
ricoprimento di insiemi di costo minimo:
Dato un universo U di n elementi, una collezione S = {S1 , . . . , Sk }
di sottoinsiemi di U ed un costo C(S) ≥ 0 per ogni S ∈ S, trovare
una sottocollezione C di S di costo minimo tra quelle che coprono
tutti gli elementi di U .
L’algoritmo goloso sceglie, ad ogni iterazione, l’insieme pi`u conveniente, ossia
quello il cui costo diviso per il numero di nuovi elementi che esso copre risulta
minimo. In altre parole, detto K l’insieme degli elementi gi`a coperti dagli insiemi
scelti precedentemente, l’algoritmo sceglie l’insieme S che minimizza il costo
unitario α = C(S)/|S \ K| pagato per i nuovi elementi coperti da S. L’algoritmo
e` quindi il seguente
MSC(S)
1 “Sia C la collezione vuota”
2 K =∅
3 while K = U
4
“seleziona l’insieme S ∈ S che minimizza α =
5
for “ogni x ∈ S \ K”
6
p(x) = α
7
K = K ∪S
8
“aggiungi S alla collezione C”
9 return C
C(S)
”
|S\K|
102
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Sia x1 , . . . , xn la lista degli elementi di U nell’ordine in cui sono stati coperti
con l’algoritmo MSC e sia CO PT il costo di un ricoprimento ottimo CO PT . Il costo
della soluzione trovata con l’algoritmo MSC e` invece
n
CMSC =
C(S) =
S∈C
p(xk )
k=1
Vale il seguente
Lemma 2.3.1 p(xk ) ≤ CO PT /(n − k + 1) per ogni k = 1, . . . , n.
Dimostrazione. Ad ogni iterazione gli insiemi in CO PT \ C coprono gli elementi in
U \ K con un costo unitario minore o uguale a CO PT /|U \ K|. Nell’iterazione in
cui l’elemento xk e` stato coperto dall’algoritmo MSC l’insieme U \ K conteneva
almeno n − k + 1 elementi. Siccome xk e` stato coperto con l’insieme S che
minimizza C(S)/|S \ K| possiamo concludere che
p(xk ) ≤
CO PT
CO PT
≤
.
|U \ K|
n−k+1
Dal precedente Lemma si ottiene immediatamente il seguente
Teorema 2.3.2 CMSC ≤ Hn CO PT dove Hn = 1 + 12 + . . . + n1 e` l’n-esimo mumero
armonico.
Dimostrazione. Basta osservare che
n
n
p(xk ) ≤
CMSC =
k=1
CO PT
= Hn CO PT
k=1 n − k + 1
Esercizio 3 Nel problema Msc la frequenza di un vertice f (v) e` il numero di
insiemi in S che contengono v e la frequenza massima f e` la frequenza del vertice
di frequenza massima. Mostrare che il problema Msc con f = 2 e` equivalente al
problema Mvc. Suggerimento: Gli insiemi che contengono vertici con frequenza
1 devono appartenere tutti alla copertura. Sia V la loro unione e consideriamo
l’insieme U = U \ V e la collezione S degli insiemi S = S \ V . Ogni elemento
in U appartiene esattamente a due insiemi in S . Considerare un grafo avente gli
insiemi S ∈ S come vertici e un arco tra due vertici S1 ed S2 se S1 ∩ S2 = ∅.
2.3. PROGETTAZIONE DI ALGORITMI DI APPROSSIMAZIONE
2.3.2
103
Stratificazione
La tecnica di progettazione di algoritmi di approssimazione mediante stratificazione si pu`o illustrare bene usando il problema della copertura di insiemi. Noi la
illustreremo sul problema Mvc che sappiamo essere equivalente al problema Msc
con frequenza f = 2. L’algoritmo che otteniamo ha coefficiente di approssimazione 2. Lasciamo come problema l’estensione ad algoritmi con coefficiente di
approssimazione f per il problema Msc con frequenza f qualsiasi.
L’idea della stratificazione e` quella di scomporre la funzione peso definita sui
vertici in funzioni, dette funzioni ponderate sui gradi, definite su di una sequenza
annidata di sottografi.
Introduciamo alcune notazioni. Sia w la funzione che assegna costo w(v) ≥
0 ad ogni vertice v del grafo dato G = (V, E). Diciamo che la funzione w e`
ponderata sui gradi se esiste una costante c > 0 tale che w(v) = c · deg(v) per
ogni vertice v. L’importanza di questa definizione e` catturata dal seguente:
Lemma 2.3.3 Se w e` una funzione ponderata sui gradi allora w(V ) ≤ 2CO PT .
Dimostrazione. Sia K una copertura ottima in G. Siccome K copre tutti gli archi
deg(v) ≥ |E|
v∈K
Quindi w(K) ≥ c|E|. Siccome
v∈V
deg(v) = 2|E| possiamo concludere che
w(V ) = 2c|E| ≤ 2w(K) = 2CO PT
Definiamo la massima funzione ponderata sui gradi in w nel seguente modo:
si tolgono dal grafo tutti i vertici di grado 0 e sugli altri vertici calcoliamo c =
min{w(v)/deg(v)}. La funzione cercata e` allora t(v) = c · deg(v). Definiamo
inoltre la funzione residua w (v) = w(v) − t(v).
L’algoritmo per la scomposizione di w in funzioni ponderate sui gradi opera
nel modo seguente. Sia G0 = G e sia D0 ⊂ V l’insieme dei suoi vertici di
grado 0. Toglie da G0 i vertici D0 e sul grafo indotto calcola la massima funzione
ponderata sui gradi. Sia W0 i vertici con costo residuo 0; questi vertici vengono
inclusi nella copertura di vertici. Sia G1 il grafo indotto sull’insieme di vertici
V \ (D0 ∪ W0 ). L’algoritmo ripete le stesse operazioni partendo dal grafo G1 con
la funzione residua e termina quando tutti i vertici hanno grado 0.
Siano G0 , . . . , Gk−1 i grafi cos`ı ottenuti e siano t0 , . . . , tk−1 le funzioni ponderate sui gradi definite su tali grafi. La copertura di vertici calcolata e` quindi
K = W0 ∪ . . . ∪ Wk−1 . Ovviamente V − K = D0 ∪ . . . ∪ Dk .
104
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
V4
D4
V3 W3
D3
V2 W2
V1
V0
D2
W1
D1
W0
D0
Figura 2.4: Illustrazione della stratificazione per il problema Mvc.
Teorema 2.3.4 L’algoritmo di stratificazione per il problema Mvc ha coefficiente
di approssimazione 2 qualunque siano i costi dei vertici.
Dimostrazione. Dobbiamo dimostrare che K e` una copertura di vertici per G e
che w(K) ≤ 2 · CO PT .
Supponiamo, per assurdo, che K non sia una copertura di vertici per G. Deve
allora esistere un arco uv tale che u ∈ Di e v ∈ Dj per qualche i, j. Assumiamo
i ≤ j. Dunque l’arco uv appartiene a Gi contraddicendo l’ipotesi che u abbia
grado 0.
Sia K ∗ una copertura di vertici ottima. Consideriamo un vertice v ∈ K che
appartiene alla copertura di vertici. Se v ∈ Wj il suo costo pu`o essere scomposto
nel modo seguente:
w(v) =
ti (v)
i≤j
Consideriamo ora un vertice v ∈ V \ K che non appartiene alla copertura di
vertici. Se v ∈ Dj vale il seguente limite inferiore per il suo costo
w(v) >
ti (v)
i<j
Una osservazione importante e` che ad ogni strato i, l’insieme K ∗ ∩ Vi e` una
copertura di vertici per Gi = (Vi , Ei ) in quanto Gi e` il grafo indotto su Vi . Quindi,
per il Lemma 2.3.3, ti (K ∩ Vi ) ≤ 2 · ti (K ∗ ∩ Vi ). Per la scomposizione dei costi
appena vista abbiamo
k−1
k−1
ti (K ∗ ∩ Vi ) ≤ 2 · CO PT
ti (K ∩ Vi ) ≤ 2 ·
w(K) =
i=0
i=0
2.3. PROGETTAZIONE DI ALGORITMI DI APPROSSIMAZIONE
2.3.3
105
Utilizzo di un limite inferiore
Consideriamo il problema CO PT = minx∈R f (x). Possiamo ottenere un limite
inferiore per CO PT con la tecnica del rilassamento. Un rilassamento del problema
precedente e` un qualsiasi problema Linf = minx∈S g(x) tale che
1. R ⊆ S e
2. g(x) ≤ f (x) per ogni x ∈ R.
Queste due condizioni implicano infatti
Linf = min g(x) ≤ min f (x) = CO PT
x∈S
x∈R
f
g
CO PT
Linf
x¯ x∗
Figura 2.5: Il problema CO PT = minx∈R f (x) ed il suo rilassamento Linf =
minx∈S g(x). La funzione obiettivo f (x) del problema originale e` tratteggiata
poich´e essa e` definita su di un sottoinsieme R dell’insieme S su cui e` definita la
funzione obiettivo del problema rilassato. Il costo Linf = f (x∗ ) della soluzione
x∗ del problema rilassato e` minore o uguale del costo CO PT = f (¯
x) della soluzione
x¯ del problema originale.
Molti rilassamenti classici si ottengono con la programmazione lineare. Vi
sono per`o delle limitazioni sulla bont`a delle approssimazioni ottenute con la programmazione lineare. Per illustrare questo fatto mostriamo come, usando la programmazione lineare, si possa ottenere un algoritmo di 2-approssimazione per il
problema del minimo ricoprimento di vertici (Mvc che sappiamo essere MAXSNP-difficile). Mostreremo inoltre che con tale tipo di rilassamento non si pu`o
ottenere un algoritmo di approssimazione migliore.
106
2.3.4
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Un rilassamento di tipo LP per il problema del minimo
ricoprimento di vertici
Un ricoprimento di vertici in un grafo G = (V, E) e` un sottoinsieme U dei vertici
tale che ogni arco sia incidente in almeno un vertice di U . Il problema Mvc del
minimo ricoprimento di vertici e` il seguente:
Dato un grafo G = (V, E) con un costo cv ≥ 0 associato ad ogni
vertice v ∈ V trovare un ricoprimento U ⊂ V che minimizza
CU =
cv
v∈U
Questo problema si pu`o esprimere come un problema di programmazione
lineare intera nel modo seguente
cv x v
CO PT = min
v∈V
xv ∈ {0, 1} per ogni v ∈ V
xu + xv ≥ 1 per ogni uv ∈ E
dove la funzione obiettivo e` la funzione f (x) = v∈V cv xv e la regione ammissibile e` l’insieme R di tutte le n-uple di valori x = {xv | v ∈ V } che soddisfano i
vincoli.
Ricordando che i vertici di un ipercubo unitario n-dimensionale hanno per
coordinate le sequenze di n valori in {0, 1}, possiamo rappresentare graficamente
la regione ammissibile come insieme di vertici di tale ipercubo: sono esattamente
tutti i vertici dell’ipercubo che non hanno due coordinate nulle in corrispondenza
di due vertici del grafo connessi da un arco.
Possiamo rilassare tale problema nel problema di programmazione lineare
Linf = min
cv x v
v∈V
0 ≤ xv ≤ 1 per ogni v ∈ V
xu + xv ≥ 1 per ogni uv ∈ E
In questo caso la funzione obiettivo e` la stessa mentre la regione ammissibile S
contiene la regione ammissibile R del problema originale.
La regione S e` il poliedro ottenuto sezionando l’ipercubo unitario n-dimensionale con gli iperpiani xu + xv = 1 relativi agli archi uv ∈ E (in Figura 2.6
2.3. PROGETTAZIONE DI ALGORITMI DI APPROSSIMAZIONE
107
e` illustrata la regione S per il caso G = K3 ). Sono quindi soddisfatte le due
condizioni perch´e questo sia effettivamente un rilassamento.
Dunque Linf ≤ CO PT e questo ci permette di provare che un certo algoritmo
H e` di α-approssimazione per il problema Mvc mostrando che CH ≤ α Linf .
(1, 1, 1)
( 12 , 12 , 12 )
(0, 0, 0)
Figura 2.6: La regione ammissibile del problema rilassato nel caso G = K3 . La
regione ammissibile e` quella a destra.
Una limitazione di questo tipo di rilassamento e` che ci sono grafi per i quali Linf e` circa 21 CO PT per cui non lo si pu`o usare per dimostrare un rapporto di
approssimazione α < 2 (altrimenti l’algoritmo H darebbe un risultato migliore
dell’ottimo).
Un grafo di questo tipo e` Kn : il grafo completo di n vertici con pesi tutti uguali
ad 1. Un ricoprimento U deve contenere almeno n−1 vertici (altrimenti ci sarebbe
un arco tra due vertici che non stanno in U ). Quindi CO PT = n − 1. Nel problema
1
C .
rilassato possiamo avere xv = 21 per ogni v ∈ V per cui Linf ≤ n2
2 O PT
2.3.5
Come usare il rilassamento
Ci sono due modi principali per ottenere una soluzione approssimata dalla soluzione del problema rilassato: il metodo dell’arrotondamento e il metodo primaleduale. Illustreremo queste due tecniche sul problema Mvc del minimo ricoprimento di vertici.
Arrotondamento
Si trova una soluzione x∗ del problema rilassato e quindi si arrotonda x∗ al “pi`u
vicino” x ∈ R (dove R e` la regione ammissibile del problema originale). Infine
108
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
f
g
αLinf
f (x )
CO PT
Linf
x¯
x x∗
Figura 2.7: L’arrotondamento x della soluzione x∗ del problema rilassato.
Bisogna trovare un x ∈ R che sia vicino a x∗ e tale che f (x ) ≤ αg(x∗ ).
si dimostra che f (x ) ≤ α g(x∗ ) da cui
f (x ) ≤ α Linf ≤ α COT T
Talvolta, come vedremo in seguito, risulta utile la randomizzazione. In tal
caso l’arrotondamento x ∈ R di x∗ viene scelto casualmente in modo da ottenere
un valore atteso E[f (x )] ≤ α g(x∗ ). Algoritmi di questo tipo possono talvolta
essere derandomizzati se si riesce a trovare un x ∈ R tale che f (x ) ≤ E[f (x )].
Arrotondamento per il problema Mvc
Questo algoritmo e` dovuto a Hochbaum [14]. Sia x∗ la soluzione ottima del
problema rilassato. Prendiamo
1
U = {v ∈ V | x∗v ≥ }
2
e proviamo che questa e` una 2-approssimazione per il problema Mvc.
Chiaramente U e` una copertura in quanto per ogni arco uv abbiamo x∗u + x∗v ≥
1 il che implica che o x∗u ≥ 21 oppure x∗v ≥ 12 . Inoltre
cv 2 x∗v ≤
cv ≤
v∈U
v∈U
in quanto 2 x∗v ≥ 1 per ogni v ∈ U .
cv 2 x∗v = 2 Linf
v∈V
2.3. PROGETTAZIONE DI ALGORITMI DI APPROSSIMAZIONE
109
g
f
αg(xmin )
αh(ymax )
αh(y)
f (x)
CO PT
g(xmin )
h(ymax )
h(y)
h
y ymax
x¯ x xmin
Figura 2.8: Il metodo Primale-Duale. Non serve risolvere nessuno dei tre problemi originale, rilassato o duale. E` sufficiente trovare un y ∈ D e un x ∈ R tali che
f (x) ≤ α h(y).
Primale-Duale
Consideriamo qualche problema duale debole del problema rilassato per cui
max{h(y) | y ∈ D} ≤ min{g(x) | x ∈ S}
e costruiamo x ∈ R a partire da un y ∈ D in modo tale che
f (x) ≤ α h(y) ≤ α h(ymax ) ≤ α g(xmin ) ≤ α CO PT
Notiamo che y pu`o essere qualsiasi valore nella regione ammissibile D del
problema duale e non necessariamente la soluzione ottima ymax .
Primale-Duale per il problema Mvc
Questo algoritmo e` dovuto a Bar-Yehuda ed Even [3]. Formuliamo dapprima il
problema duale debole del problema rilassato.
Sia yuv una variabile per ogni arco uv ∈ E. Il problema duale debole e`
max
yuv
uv∈E
yuv ≤ cv per ogni v ∈ V
uv∈∆(v)
yuv ≥ 0
per ogni uv ∈ E
110
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Questo problema di massimizzazione e` effettivamente un duale debole del
problema rilassato. Infatti

yuv ≤
uv∈E
yuv (xu + xv ) =
uv∈E

yuv  ≤
 xv
v∈V
cv x v
v∈V
uv∈∆(v)
L’algoritmo opera nel modo seguente.
1. Inizializza l’insieme U (il ricoprimento di vertici) con l’insieme vuoto, pone
yuv = 0 per ogni uv ∈ E e inizializza l’insieme F = E (degli archi da
visitare).
2. sceglie un arco uv ∈ F ed aumenta yuv fino a far diventare uguaglianza
una delle due diseguaglianze relative ai vertici u e v. Supponiamo che la
disuguaglianza diventi uguaglianza per v.
3. Aggiunge v a U e toglie da F tutti gli archi incidenti in v.
4. Ripete i due punti precedenti finch´e F non diventa vuoto. A quel punto U e`
il ricoprimento calcolato.
Che U sia un ricoprimento e` ovvio. Inoltre, siccome per ogni v ∈ U la
disuguaglianza e` una uguaglianza
2.4
v∈U uv∈∆(v)
2 yuv ≤ 2 Linf
|U ∩ {u, v}| yuv ≤
yuv =
cv =
v∈U
uv∈E
uv∈E
Problema del matching perfetto di costo minimo
In questa sezione illustreremo la potenza del metodo Primale-Duale per trovare algoritmi di approssimazione. Consideriamo il problema Mpm del matching
perfetto di costo minimo:
“Dato il grafo completo Kn = (V, E) con un numero pari di vertici
ed un costo non negativo cuv associato ogni arco uv ∈ E, determinare
un matching perfetto M di costo CM =
cuv minimo.”
uv∈M
Il primo algoritmo polinomiale per questo problema e` dovuto ad Edmonds [7]
ed ha complessit`a O(n4 ).
2.4. PROBLEMA DEL MATCHING PERFETTO DI COSTO MINIMO
111
L’algoritmo asintoticamente pi`u veloce e` dovuto a Gabov [10] ed ha complessit`a asintotica O(n(m + n lg n)) dove m = |E|.4 Per grafi densi, in cui
m = Θ(n2 ), si ottiene un tempo calcolo O(n3 ) mentre per grafi sparsi, in cui
m = O(n log n), si ottiene O(n2 log n). Questo algoritmo e` per`o molto complicato per cui la costante nascosta dalla notazione asintotica risulta molto grande, e
questo lo rende troppo lento per molte applicazioni pratiche.
Per questo problema vedremo invece un algoritmo di approssimazione, dovuto
a Goemans e Williamson [12] che richiede√tempo O(n2 log n). Questo limite e`
stato successivamente ridotto ad O(n2 + n m log log n) da Gabow, Goemans e
Williamson [11].
Da notare che bench´e il problema Mpm approssimato sia polinomiale come il
problema esatto, la tecnica usata nell’algoritmo di approssimazione di Goemans
e Williamson e` abbastanza generale da poter essere usata anche per approssimare
molti problemi NP-difficili.
L’algoritmo di Goemans e Williamson e` di 2-approssimazione: trova un matching perfetto di costo non maggiore di due volte il costo del matching ottimo.
Esso richiede che i costi degli archi soddisfino la disuguaglianza triangolare.
2.4.1
Una formulazione di Mpm come problema di programmazione lineare
L’algoritmo di Goemans e Williamson usa la programmazione lineare e la dualit`a. Infatti, come vedremo tra poco, il problema Mpm si pu`o formulare come un
problema di programmazione lineare.
Il problema di programmazione lineare cos`ı ottenuto contiene un numero di
vincoli estremamente grande ma fortunatamente esso non deve essere risolto dall’algoritmo che invece si limita soltanto a trovare una soluzione ammissibile del
problema duale che soddisfi il rapporto di approssimazione 2 (senza risolvere il
problema).
La formulazione di Mpm in programmazione lineare intera e`
CO PT = min
cuv xuv
uv∈E
xuv ∈ {0, 1}
4
per ogni uv ∈ E
Noi abbiamo definito il problema Mpm su grafi completi. Qui ci si riferisce a grafi qualsiasi. I
due problemi sono per`o equivalenti. Per grafi incompleti basta aggiungere gli archi mancanti con
peso ∞.
112
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
xuv = 1
per ogni u ∈ V
uv∈∆(u)
dove ∆(u) e` l’insieme degli archi incidenti in u.
Prima di formulare il rilassamento come problema di programmazione lineare
facciamo la seguente osservazione.
Sia
D = {S | S ⊂ V, |S| dispari}
la famiglia di tutti i sottoinsiemi propri di V che contengono un numero dispari di
vertici.
Consideriamo un matching perfetto M ed un insieme dispari S ∈ D e sia
∆(S) l’insieme degli archi che intersecano il taglio (S, S). Siccome S contiene
un numero dispari di vertici deve esserci qualche arco di M avente un estremo in
S ed uno in S e quindi M ∩ ∆(S) = ∅.
Avendo presente questa osservazione possiamo formulare nel modo seguente
un rilassamento di Mpm come problema di programmazione lineare
cuv xuv
Z = min
uv∈E
xuv ≥ 0
xuv ≥ 1
per ogni uv ∈ E
per ogni S ∈ D
uv∈∆(S)
infatti, se M e` un matching perfetto e poniamo xuv = 1 per uv ∈ M ed xuv = 0
altrimenti, allora tutti i vincoli sono soddisfatti.
Dunque la soluzione Z del problema di programmazione lineare e` un limite
inferiore per il costo di ogni matching perfetto e, in particolare, Z ≤ CO PT .
Il problema di programmazione lineare precedente ha un vincolo per ogni sottoinsieme S ∈ D, troppi per poterlo risolvere efficientemente. Noi non cercheremo di risolverlo, lo useremo soltanto assieme al suo duale per progettare ed
analizzare l’algoritmo di approssimazione.
Siccome il problema rilassato e` in forma standard esso ha il duale stretto
Z = max
yS
S∈D
yS ≥ 0
yS ≤ cuv
S∈D
uv∈∆(S)
per ogni S ∈ D
per ogni uv ∈ E
2.4. PROBLEMA DEL MATCHING PERFETTO DI COSTO MINIMO
113
Questo programma duale ha la stessa soluzione Z del programma rilassato
(essendo la dualit`a stretta).
Usiamo il problema duale per verificare che il costo del matching perfetto
calcolato dall’algoritmo e` effettivamente minore o uguale del doppio del costo del
matching ottimo. A questo scopo l’algoritmo fornisce in output due cose
1. un matching perfetto M , e
2. una soluzione y del problema duale tale che CM ≤ 2
yS .
S∈D
Siccome y e` una soluzione ammissibile sappiamo che
yS ≤ Z ≤ CO PT
S∈D
e dunque
CM ≤ 2Z ≤ 2CO PT
Dato che l’algoritmo e` polinomiale esso e` un algoritmo di 2-approssimazione
per Mpm.
Per essere pi`u precisi, non e` necessario che l’algoritmo calcoli effettivamente
la soluzione y; essa serve solo come strumento di analisi per dimostrare il rapporto
di approssimazione 2.
Osserviamo comunque che, bench´e vi sia un numero esponenziale di variabili yS soltanto un numero polinomiale di esse risulta diverso da 0. L’algoritmo
potrebbe quindi calcolare e stampare la soluzione y in tempo polinomiale.
Noi includeremo nell’esposizione dell’algoritmo anche il calcolo dei valori delle variabili yS ma tale calcolo pu`o essere omesso in una implementazione
effettiva dell’algoritmo.
2.4.2
Dalle foreste ai matching perfetti
Ricordiamo che una foresta F e` semplicemente un grafo aciclico non necessariamente connesso. I vertici di una foresta F si possono partizionare in componenti
connesse (gli alberi della foresta).
Indichiamo con KF la famiglia di tutte le componenti connesse di F e la suddividiamo nella sottofamiglia DF delle componenti con un numero dispari di vertici
e PF di quelle con un numero pari di vertici.
Invece di calcolare direttamente il matching perfetto M l’algoritmo calcola
dapprima una foresta F che ha tutte le componenti connesse con un numero pari
114
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
A2
v
A1
u
Ai
Ak
Figura 2.9: Illustrazione del Lemma 2.4.1
di vertici (ossia DF = ∅) dopo di che rimuove alcuni archi da F per ottenere una
foresta F , sempre con componenti pari, ma che e` minimale nel senso che se si
toglie un qualsiasi arco si ottiene almeno una componente con un numero dispari
di vertici.
Il costo della foresta F cos`ı ottenuta e` minore o uguale del doppio del valore
della soluzione ammissibile y del problema duale.
Infine da F deriva il matching perfetto M sostituendo alcune coppie di archi
consecutivi uv e vw con un unico arco uw. Per la disuguaglianza triangolare il
costo di M e` minore o uguale al costo di F e quindi minore o uguale al doppio
del valore della soluzione ammissibile y del problema duale. Quindi
yS ≤ 2Z ≤ 2CO PT
CM ≤ CF ≤ 2
S∈D
Prima di vedere nel dettaglio come l’algoritmo costruisce le foreste F ed F
mostriamo come si possa ricavare un matching M dalla foresta F . Per fare questo
ci serve la seguente conseguenza della minimalit`a di F .
Lemma 2.4.1 Tutti i vertici di F hanno grado dispari.
Dimostrazione. Supponiamo vi sia un vertice v di grado k pari e sia A la componente di F che contiene v.
Togliendo dall’albero A il vertice v e tutti gli archi ad esso incidenti si ottengono un numero pari di alberi A1 , . . . , Ak con un numero totale di vertici dispari
(vedi Figura 2.9).
Almeno uno dei sottoalberi A1 , . . . , Ak , diciamo Ai , deve avere un numero
pari di vertici (altrimenti il numero totale di vertici sarebbe pari).
Sia u ∈ Ai il vertice di Ai che in A era connesso a v dall’arco rimosso uv. Se
da A rimuoviamo l’arco uv esso si spezza in due componenti con un numero pari
di vertici contro l’ipotesi di minimalit`a di F .
2.4. PROBLEMA DEL MATCHING PERFETTO DI COSTO MINIMO
115
Possiamo trasformare F in un matching perfetto M tale che CM ≤ CF nel
seguente modo.
Consideriamo un qualsiasi vertice v di grado maggiore o uguale a 3 della foresta F e togliamo due archi vu e vw incidenti in v sostituendoli con l’arco uw.
Per la disuguaglianza triangolare il costo della foresta non pu`o aumentare.
Siccome tutti i vertici di F hanno grado dispari (per il Lemma 2.4.1), iterando
il procedimento arriviamo ad avere tutti i vertici di grado 1 ottenendo un matching
perfetto M di costo minore o uguale del costo di F .
Notiamo che il calcolo di M richiede al pi`u O(n) iterazioni.
M PM(G = (V, E), c)
1 F =∅
2 KF = {{v} | v ∈ V }
3 for “ogni S ∈ D” do yS = 0
// Pu`o essere omessa
4 for “ogni v ∈ V ” do d[v] = 0
5 // d[v] memorizza la somma delle variabili yS tali che v ∈ S.
6 while DF = ∅
7
“Cerca uv ∈ ∆(K) con K ∈ DF che minimizza
cuv − d[u] − d[v]
.”
8
δ=
λ(K) + λ(K )
9
// Dove K ∈ KF e` la componente che contiene l’altro estremo di
10
// uv e λ(C) = 1 se la componente C e` dispari, λ(C) = 0 se e` pari.
11
F = F ∪ {uv}
12
for “ogni componente C ∈ DF ”
13
for “ogni vertice v ∈ C”
14
d[v] = d[v] + δ
15
yC = yC + δ
// Pu`o essere omessa
16
KF = KF \ {K, K } ∪ {K ∪ K }
17 F = F
18 while “esiste uv ∈ F la cui rimozione crea due componenti pari”
19
F = F \ {uv}
20 M = F
21 while “esiste v ∈ V di grado maggiore di 1”
22
“cerca due vertici u e w adiacenti a v”
23
M = M \ {vu, vw} ∪ {uw}
24 return M
Figura 2.10: L’algoritmo M PM
116
2.4.3
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
L’algoritmo
L’algoritmo ha la seguente struttura astratta
1. Inizia con F = ∅ ed yS = 0 per ogni S ∈ D.
2. Finch´e DF = ∅ aumenta i valori delle variabili yS relative alle componenti
dispari K ∈ DF della massima quantit`a δ per cui rimangono soddisfatti
tutti i vincoli
yS ≤ cuv
S∈D, uv∈∆(S)
del problema duale. Questo trasforma in uguaglianza il vincolo relativo ad
almeno un arco uv.
Aggiungiamo quindi ad F un arco uv che connette un vertice u di una
componente dispari ad un vertice v di un’altra componente (dispari o pari)
e per il quale il vincolo sia diventato una uguaglianza.
3. Trasforma F in una foresta F minimale.
4. Ricava da F un matching perfetto M .
La descrizione formale dell’algoritmo e` riportata in Figura 2.10 dove le istruzioni che assegnano valore alle variabili yS sono annotate con un commento che
dice che in una implementazione effettiva esse possono essere omesse.
2.4.4
Un esempio di esecuzione dell’algoritmo
Illustriamo l’algoritmo con un esempio. Per semplicit`a consideriamo un grafo
completo di 8 vertici rappresentati con punti del piano e assumiamo che i costi
degli archi siano le loro lunghezze nella rappresentazione piana adottata (vedi
Figura 2.11).
Nella Figura 2.11 i cerchi concentrici indicano i successivi incrementi di d[u]
relativi al vertice u.
All’inizio tutti i vertici costituiscono componenti separate e d[u] = 0 per ogni
vertice u. Siccome tutte le componenti sono dispari
δ=
cuv − 0 − 0
= cuv /2
1+1
l’arco selezionato e` quindi quello tra i vertici 7 e 8 che sono i pi`u vicini tra loro.
2.4. PROBLEMA DEL MATCHING PERFETTO DI COSTO MINIMO
117
Ogni d[v] viene quindi aumentato di δ come indicato dal primo cerchio attorno
ad ogni vertice ed i due vertici 7 e 8 vengono riuniti in un’unica componente {7, 8}
di cardinalit`a pari.
In generale, ad ogni iterazione i contorni delle componenti dispari vengono
allargati della minima quantit`a δ tale che i contorni di due componenti K e K
arrivino a toccarsi. L’arco prescelto e` quindi quello che connette due vertici u ∈ K
e v ∈ K i cui cerchi si toccano.
L’arco successivo prescelto e` quello tra i due vertici 3 e 5. Osserviamo che il
contorno della componente {7, 8} non cambia in quanto essa ha cardinalit`a pari.
In Figura 2.11 sono indicati tutti gli archi selezionati e le successive espansioni
dei contorni delle regioni.
6
4
3
5
8
7
1
2
Figura 2.11: Illustrazione dell’algoritmo Mpm
2.4.5
Analisi dell’algoritmo
Lemma 2.4.2 I valori delle variabili yS calcolati dall’algoritmo precedente sono
una soluzione ammissibile del problema duale.
118
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Dimostrazione. Dobbiamo dimostrare che le variabili yS soddisfano i vincoli del
problema duale
yS ≥ 0
per ogni S ∈ D
per ogni uv ∈ E
yS ≤ cuv
(2.1)
(2.2)
S∈D
uv∈∆(S)
La dimostrazione e` per induzione sulle iterazioni del ciclo while.
All’inizio la cosa e` vera in quanto tutte le variabili yS sono inizializzate a 0 e
i costi cuv sono non negativi. Inoltre, all’inizio, e` pure vero che
d[v] =
per ogni v ∈ V
yS
(2.3)
v∈S∈D
in quanto anche i valori d[v] sono inizializzati a 0.
Supponiamo quindi che 2.1, 2.2 e 2.3 siano vere prima di eseguire una iterazione del ciclo while e mostriamo che esse sono ancora vere dopo averla eseguita.
Sia uv un generico arco. Ci sono due possibilit`a: che i vertici u e v appartengano alla stessa componente oppure appartengano a componenti distinte.
Nel primo caso non vi e` nessuna componente K ∈ KF per la quale uv ∈
∆(K). Di conseguenza, siccome le uniche variabili yS che possono cambiare
sono quelle per cui S = K ∈ KF tutte le variabili yS tali che uv ∈ ∆(S)
rimangono invariate. Dunque la disequazione 2.2 relativa all’arco uv rimane vera.
Nel secondo caso u ∈ K e v ∈ K con K = K . Se u e v non appartengono
alla stessa componente connessa non potevano appartenere alla stessa componente
connessa neppure nelle iterazioni precedenti e quindi tutte le variabili yS relative
a insiemi dispari che contengono sia u che v non sono mai state incrementate e
dunque hanno valore 0. Possiamo dunque scrivere
yS =
S∈D
uv∈∆(S)
yS +
u∈S∈D
yS = d[u] + d[v]
v∈S∈D
dove la prima uguaglianza deriva dal fatto che le uniche variabili yS che compaiono nel secondo termine ma non nel primo sono quelle contenenti sia u che v e
che quindi sono nulle.
La seconda uguaglianza e` invece giustificata dall’equazione 2.3. Inoltre, per
l’equazione 2.2,
d[u] + d[v] =
yS ≤ cuv
S∈D
uv∈∆(S)
2.4. PROBLEMA DEL MATCHING PERFETTO DI COSTO MINIMO
119
Possiamo, a questo punto osservare che, siccome questo vale per ogni coppia
di componenti K = K ed ogni arco uv con u ∈ K e v ∈ K
δ=
min
u∈K,v∈K
K=K
cuv − d[u] − d[v]
≥0
λ(K) + λ(K )
e dunque i valori delle variabili yS possono solo aumentare per cui le disequazioni
2.1 rimangono vere.
Osserviamo inoltre che una variabile yS viene incrementata di δ se e solo se
S = K ∈ DF e in tal caso d[v] viene incrementato di δ per ogni v ∈ S. Dunque
la parte sinistra d[u] dell’equazione 2.3 viene incrementata di δ soltanto se u ∈
K ∈ DF e in tal caso soltanto una delle variabili sommate nella parte destra
viene incrementata di δ, e precisamente la variabile yK relativa alla componente
K che contiene u. Quindi anche le equazioni 2.3 rimangono vere.
Tornando alla dimostrazione che l’equazione 2.2 relativa all’arco uv rimane
vera osserviamo che una variabile yS viene incrementata di δ soltanto se S =
K ∈ DF e quindi λ(K) = 1. Quindi, indicando con d [u] e d [v] i valori di d[u] e
d[v] alla fine dell’iterazione
d [u] = d[u] + δ λ(K)
d [v] = d[v] + δ λ(K )
Per la minimalit`a di δ
cuv − d[u] − d[v]
λ(K) + λ(K )
e quindi, indicando con yS i valori delle variabili yS alla fine dell’iterazione
δ≤
yS = d [u] + d [v]
S∈D
uv∈∆(S)
= d[u] + δ λ(K) + d[v] + δ λ(K )
= d[u] + d[v] + δ(λ(K) + λ(K ))
cuv − d[u] − d[v]
≤ d[u] + d[v] +
(λ(K) + λ(K ))
λ(K) + λ(K )
= cuv
Dunque anche le equazioni 2.2 rimangono vere per ogni arco uv.
Come osservazione finale, notiamo che quando l’algoritmo sceglie un arco uv
il corrispondente vincolo 2.2 diventa un’uguaglianza. Questo significa che
yS = cuv
S∈D
uv∈∆(S)
per ogni uv ∈ F .
120
2.4.6
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Ultimo passo dell’algoritmo e sua correttezza
Quando termina il primo ciclo while la foresta F contiene solo componenti pari.
Diciamo che un arco uv nella foresta F e` in posizione pari se la sua rimozione
suddivide la componente a cui appartiene in due componenti pari, diciamo che e`
in posizione dispari se la divide in due componenti dispari.
Il secondo ciclo while rimuove tutti gli archi in posizione pari. Dunque alla
fine la foresta F cos`ı ottenuta ha tutte le componenti pari ed e` minimale rispetto a
questa propriet`a.
In Figura 2.12 sono evidenziati gli archi in posizione pari di una componente
di F e le corrispondenti componenti in F ottenute rimuovendo tali archi.
F
F
Figura 2.12: Una componente di F con evidenziati gli archi in posizione pari e le
corrispondenti componenti in M ottenute rimuovendo tali archi.
Osserviamo che l’ordine in cui vengono rimossi gli archi e` irrilevante. Infatti dopo aver rimosso un arco in posizione pari i rimanenti archi non cambiano
posizione: se erano in posizione pari rimangono in posizione pari, se erano in
posizione dispari rimangono in posizione dispari. Di conseguenza gli archi di F
che rimangono in F sono tutti e soli quelli in posizione dispari, ossia
F = {uv ∈ F | la rimozione di uv crea due componenti dispari}
Il Teorema seguente prova che il costo della foresta F cos`ı ottenuta e` al pi`u
pari al doppio del costo della soluzione del problema duale.
Siccome abbiamo visto come ottenere da F un matching perfetto M di costo
minore o uguale a quello di F abbiamo un algoritmo di 2-approssimazione per il
problema M P M .
2.4. PROBLEMA DEL MATCHING PERFETTO DI COSTO MINIMO
121
Teorema 2.4.3 Sia
F = {uv ∈ F | la rimozione di uv crea due componenti dispari}
cuv ≤ 2
Allora
uv∈F
yS .
S∈D
Dimostrazione. Ricordiamo che
cuv =
yS
per ogni uv ∈ F
S∈D
uv∈∆(S)
e quindi
cuv =
|F ∩ ∆(S)| yS
yS =
uv∈F
uv∈F
S∈D
uv∈∆(S)
S∈D
Dobbiamo quindi mostrare che
|F ∩ ∆(S)| yS ≤ 2
yS
S∈D
S∈D
Dimostreremo questa disequazione per induzione sui passi dell’algoritmo. Pi`u
precisamente mostreremo che essa e` vera con i valori iniziali delle variabili yS
e che essa rimane vera anche ad ogni iterazione dopo che i valori delle variabili
relative alle componenti dispari sono incrementati di δ.
Notiamo che F denota il risultato finale dell’algoritmo e quindi non cambia
nei passi induttivi.
All’inizio tutte le yS sono 0 e quindi la disequazione e` banalmente vera. Supponiamo quindi che tale disequazione sia vera a qualche stadio intermedio dell’algoritmo e sia F la foresta costruita a tale stadio.
Ci basta mostrare che essa e` vera anche dopo che i valori delle variabili relative
alle componenti K ∈ DF sono incrementati di δ. Ossia che l’aumento della parte
sinistra della disequazione e` al pi`u il doppio dell’aumento della parte destra.
|F ∩ ∆(K)| ≤ 2δ|DF |
δ
K∈D
F
ovvero
|F ∩ ∆(K)| ≤ 2|DF |
K∈D
F
122
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Sappiamo che la foresta minimale F e` ottenuta dalla foresta F come calcolata
alla fine del primo ciclo while eliminando gli archi in posizione pari (quelli tratteggiati in Figura 2.13) e che l’ordine in cui tali archi vengono tolti e` irrilevante.
Sia F la foresta F da cui sono stati tolti soltanto gli archi in posizione pari che
sono stati aggiunti dopo lo stadio considerato, ossia quelli che stanno in F \ F
(gli archi tratteggiati rossi in Figura 2.13).
K5
K4
K6
K3
K8
K7
K9
K2
K1
Figura 2.13: La costruzione del grafo H. Gli archi neri (sia continui che tratteggiati) costituiscono la foresta F prima di eseguire una iterazione del ciclo while
principale. K 1 , . . . , K 9 sono le componenti di F . Gli archi rossi (sia continui
che tratteggiati) sono gli archi che verranno aggiunti dall’algoritmo per ottenere
la foresta F finale con tutte componenti pari. Gli archi tratteggiati (sia neri che
rossi) sono quelli che verranno eliminati per ottenere da F la foresta minimale
F . Quindi la foresta minimale F e` costituita dai soli archi continui (neri o rossi).
Il grafo H ha come vertici le componenti K 1 , . . . , K 9 e come archi soltanto gli
archi rossi continui.
Per ogni componente K di F abbiamo che F ∩ ∆(K) = ∆F (K) e pertanto
|F ∩ ∆(K)| =
K∈D
F
|∆F (K)|
K∈D
F
Se nella foresta F contraiamo ogni componente K in un unico vertice otteniamo
un grafo H che ha come vertici le componenti K di F e come archi uscenti dal
2.4. PROBLEMA DEL MATCHING PERFETTO DI COSTO MINIMO
123
vertice K gli archi ∆H (K) = ∆F (K). Dunque dobbiamo dimostrare
|∆H (K)| ≤ 2|DF |
K∈D
(2.4)
F
Siccome H e` anch’esso una foresta il numero di archi e` uguale al numero di
vertici meno il numero k di componenti della foresta H stessa, ossia
|∆H (K)| +
K∈D
|∆H (K)| = 2(|KF | − k) = 2|DF | + 2|PF | − 2k
K∈P
F
F
ovvero
|∆H (K)| = 2|DF | + 2|PF | −
K∈D
|∆H (K)| − 2k
K∈P
F
= 2|DF | +
F
(2 − |∆H (K)|) − 2k
K∈P
F
Dunque, per dimostrare la disuguaglianza (2.4) basta dimostrare che
(2 − |∆H (K)|) − 2k ≤ 0
K∈P
(2.5)
F
Consideriamo una componente pari K ∈ PF . Sia K la componente di F che
contiene la componente K di F . Ad esempio, se in Figura 2.13 consideriamo la
componente pari K 2 la componente K e` l’unione delle componenti K 1 , K 2 e K 9 .
Dato che F e` stata ottenuta da F eliminando degli archi, I vertici di ogni
albero della foresta F o sono tutti contenuti in K oppure sono tutti esterni a K.
Ad esempio la componente K unione delle componenti K 1 , K 2 e K 9 di Figura
2.13 contiene esattamente due componenti di F ciascuna costituita da due vertici
connessi con un arco continuo.
Siccome ogni componente di F ha un numero di vertici pari anche K deve
contenere un numero pari di vertici. Quindi sia K che K \ K hanno un numero
pari di vertici.
Inoltre |∆H (K)| = 1 altrimenti se togliamo da F l’unico arco in ∆H (K) la
componente che lo contiene si spezza in due componenti pari, contraddicendo la
minimalit`a di F . Dunque o |∆H (K)| ≥ 2 oppure |∆H (K)| = 0.
Nel primo caso, nella disequazione (2.5), il termine della sommatoria relativo
a K e` minore o uguale a 0. Nel secondo caso la componente K e` un vertice isolato
di H e costituisce quindi una delle k componenti di H.
Dunque le componenti per cui |∆H (K)| = 0 sono al pi`u k e pertanto la (2.5)
e` verificata ed il teorema e` dimostrato.
124
2.4.7
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Alcuni dettagli implementativi
Mostriamo come l’algoritmo si possa implementare con complessit`a O(n2 log n).
Siccome il numero di iterazioni e` al pi`u n−1 (perch´e F e` una foresta) ci basta
realizzare ciascuna iterazione in tempo O(n log n).
Le componenti di F possono essere mantenute in una struttura dati per insiemi
disgiunti in modo tale che ogni operazione di riunione di due componenti richieda
tempo O(α(n)), dove α(n) e` l’inversa della funzione di Ackerman che, ai fini
pratici, possiamo considerare O(1).
Per trovare velocemente l’arco uv da aggiungere ad F , l’algoritmo mantiene
la somma ∆ di tutti gli incrementi δ operati nelle iterazioni precedenti e per ogni
arco uv tale che u e v appartengano a due componenti distinte K ed K mantiene
aggiornato il valore
key[uv] = ∆ + D
dove D e` il valore dell’incremento δ che renderebbe il vincolo cuv ≥ d[u] + d[v]
un’uguaglianza.
Siccome i valori d[u] vengono incrementati soltanto se u appartiene ad una
componente dispari, se le due componenti sono entrambe dispari avremo
1
key[uv] = ∆ + (cuv − d[u] − d[v])
2
se una e` dispari e l’altra pari
key[uv] = ∆ + cuv − d[u] − d[v]
e infine se sono entrambe pari
key[uv] = ∆ + ∞ = ∞
Osserviamo che se l’esecuzione di una iterazione non modifica la parit`a delle
componenti contenenti u e v il valore di key[uv] relativo all’arco uv non cambia
in quanto il primo addendo ∆ viene incrementato di δ, la stessa quantit`a di cui
diminuisce il secondo addendo D.
Manteniamo un heap ordinato rispetto a key[uv] in cui inseriamo, per ogni
coppia di componenti distinte K e K , l’arco uv avente chiave key[uv] minima tra
tutti quelli che connettono un vertice u ∈ K con un vertice v ∈ K .
In questo modo, ad ogni iterazione, per ottenere l’arco uv da aggiungere ad F
basta estrarre dallo heap l’arco uv con chiave minima (costo O(log n)).
Vediamo quindi come mantenere aggiornato lo heap.
2.5. PROBLEMA DEL TAGLIO MASSIMO
125
All’inizio ∆ = 0 e d[u] = 0 per ogni vertice u. Siccome tutte le componenti
sono singoletti e quindi dispari ed ogni arco uv e` l’unico che connette le due
componenti distinte K = {u} e K = {v} dobbiamo inserire nel mucchio tutti gli
archi con key[uv] = cuv /2. Questo costa O(n2 log n) (gli archi sono n(n−1)/2 =
O(n2 )).
Ad ogni iterazione dobbiamo aggiornare le chiavi degli archi uscenti dalla
nuova componente K ∪ K che si ottiene riunendo le due componenti K e K (in
quanto la parit`a pu`o cambiare). In totale dobbiamo aggiornare un numero di archi
pari a due volte il numero di componenti K diverse sia da K che da K (costo
O(n log n)).
Dobbiamo inoltre eliminare dallo heap l’arco uv selezionato e, per ogni componente K diversa da K e da K , uno dei due archi che connettono K ∪ K a
K : quello con chiave maggiore. Costo O(n log n).
Sommando su tutte le iterazioni otteniamo quindi costo O(n2 log n).
Infine, per ottenere F da F basta effettuare una ricerca in profondit`a su F
calcolando il numero di discendenti di ogni vertice v nella foresta di ricerca in
profondit`a (compreso il vertice v stesso). Gli archi da rimuovere sono gli archi
d’albero uv tali che v abbia un numero pari di discendenti. Costo O(n).
2.5
Problema del taglio massimo
In questa sezione mostreremo come sia talvolta possibile ottenere algoritmi di
approssimazione migliori usando dei rilassamenti pi`u sofisticati di quelli lineari.
Mostreremo anche che usare la randomizzazione per arrotondare la soluzione
ottenuta mediante il rilassamento pu`o risultare molto utile.
Per illustrare questi fatti useremo il problema Max-Cut del taglio massimo
nella sua versione non pesata:
“Dato un grafo G = (V, E) trovare un taglio (S, S) tale che sia
massimo il numero di archi δ(S) = |∆(S)| che intersecano il taglio.”
Nella versione pesata ogni arco uv ha un peso cuv ed il taglio massimo (S, S)
e` quello che massimizza
CS =
cuv
uv∈∆(S)
Per semplicit`a ci concentreremo sulla versione non pesata, ma i risultati a cui
arriveremo si possono facilmente estendere al caso pesato.
126
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Si pu`o dimostrare che Max-Cut e` NP-difficile e MAX-SNP completo e pertanto non possiamo aspettarci di poter ottenere algoritmi di approssimazione aventi un rapporto di approssimazione α arbitrariamente vicino ad 1.
Ricordiamo che un algoritmo di α-approssimazione per Max-Cut e` un algoritmo polinomiale che trova un taglio (S, S) tale che δ(S) ≥ α δ(Smax ) dove
(Smax , S max ) e` il taglio massimo.
Fino al 1993 il miglior α era 0.5, ora e` 0.878 con un algoritmo dovuto a
Goemans e Williamson [13].
Cominceremo riportanto tre semplici algoritmi con rapporto di approssimazione 0.5.
Scelta casuale. Questo e` un algoritmo randomizzato. Ogni vertice u ∈ V viene
scelto casualmente con probabilit`a 1/2 indipendentemente dalle scelte degli
altri vertici. L’insieme S e` quindi l’insieme dei vertici scelti. Il valore atteso
di δ(S) e`
Pr[uv ∈ ∆(S)]
E[δ(S)] =
uv∈E
Pr[u ∈ S, v ∈ S oppure u ∈ S, v ∈ S]
=
uv∈E
=
1 1
1
( + ) = |E|
4
2
uv∈E 4
Siccome δ(Smax ) ≤ |E| otteniamo E[δ(S)] ≥ 12 δ(Smax ).
Algoritmo goloso. Numeriamo i vertici del grafo in modo che V = {1, 2, . . . , n}.
Sia
Vu = {v | v < u, uv ∈ E}
l’insieme dei vertici v che precedono u e che sono connessi ad u con un
arco uv ∈ E ed
Eu = {uv ∈ E | v ∈ Vu }
l’insieme di tali archi. Chiaramente gli insiemi Eu formano una partizione di E (gli archi sono raggruppati rispetto al maggiore dei due estremi).
L’algoritmo prende in considerazione un vertice u alla volta nell’ordine
1, 2, . . . , n e sceglie di aggiungelo ad S oppure al complementare S in modo
tale che almeno la met`a degli archi in Eu intersechino il taglio. L’algoritmo
e` quindi
2.5. PROBLEMA DEL TAGLIO MASSIMO
127
G REEDY(G = (V, E))
1 S = {1}
2 for u = 2 to n
3
if |S ∩ Vu | ≤ 21 |Eu |
4
S = S ∪ {u}
5 return S
Il vertice u viene aggiunto ad S se almeno la met`a degli archi in Eu connettono u ad un vertice v < u precedentemente scartato, ossia ad un vertice
v ∈ S. Quindi almeno una met`a degli archi in Eu interseca il taglio.
Viceversa, il vertice u viene scartato (e dunque aggiunto ad S) se almeno la
met`a degli archi in Eu connettono u ad un vertice v < u precedentemente
aggiunto ad S. Quindi, anche in questo caso, almeno una met`a degli archi
in Eu interseca il taglio. Dunque
δ(S) ≥
u∈V
1
1
|Eu | = |E|
2
2
e possiamo concludere che
1
1
δ(S) ≥ |E| ≥ δ(Smax )
2
2
Ricerca locale. Diciamo che S e` un ottimo locale se
δ(S) ≥ δ(S \ {u}) e δ(S) ≥ δ(S ∪ {v})
per ogni vertice u ∈ S e v ∈ S.
L’algoritmo di ricerca locale muove un vertice alla volta da S a S o viceversa fino ad arrivare ad un ottimo locale. Nel caso del problema non
pesato l’algoritmo e` polinomiale (ogni volta δ(S) aumenta di almeno 1
e δ(S) < n2 ). Nel caso del problema pesato la complessit`a pu`o invece
diventare esponenziale.
Dimostriamo che se S e` un ottimo locale
1
1
δ(S) ≥ |E| ≥ δ(Smax )
2
2
e quindi l’algoritmo e` di 21 -approssimazione.
128
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Osserviamo che
δ(S) =
1
|∆(S) ∩ ∆(v)|
2 v∈V
in quanto ogni arco in ∆(S) viene contato due volte nella sommatoria a
destra. Inoltre
1
|∆(S) ∩ ∆(v)| ≥ δ(v)
2
altrimenti potremmo spostare v dall’altra parte ottenendo un taglio migliore.
Dunque
δ(S) =
1
1
1
1
|∆(S) ∩ ∆(v)| ≥
δ(v) = |E|
2 v∈V
2 v∈V 2
2
Prima che fosse proposto l’algoritmo che vedremo tra poco sono stati ottenuti molti piccoli miglioramenti del rapporto di approssimazione α. Per un grafo di n nodi ed m archi si sono raggiunti successivamente i seguenti rapporti di
approssimazione:
1
,
2
1
1
+
,
2 2m
1
1
1 n−1
+
e
+
2 2n
2
4m
Asintoticamente questi sono tutti uguali a 0.5.
2.5.1
Un algoritmo randomizzato di 0.878-approssimazione
L’algoritmo che presentiamo e` randomizzato ma differisce dall’algoritmo randomizzato della scelta casuale per due importanti fatti
• La scelta di un vertice v ∈ S non e` indipendente dalla scelta degli altri
vertici.
• Il valore δ(S) del taglio risultante viene confrontato con un limite superiore
migliore di |E|.
Associamo ad ogni vertice v ∈ V del grafo un vettore unitario n-dimensionale
wv , dove n = |V | e` il numero di vertici. Ricordiamo che un vettore e` unitario se
ha norma
||w|| = w · w = w12 + . . . + wn2 = 1
Un vettore unitario individua un punto sulla sfera unitaria n-dimensionale F (n)
centrata nell’origine.
2.5. PROBLEMA DEL TAGLIO MASSIMO
129
Scegliamo casualmente un vettore unitario r e sia
(n−1)
P⊥r
= {x | x · r = 0}
il piano (n − 1)-dimensionale perpendicolare ad r e passante per l’origine.
(n−1)
Il piano P⊥r divide la sfera unitaria F (n) in una semisfera superiore
(n)
Fsup
= {w ∈ F (n) | w · r ≥ 0}
ed una semisfera inferiore
(n)
Finf = {w ∈ F (n) | w · r < 0}
Dividiamo i vertici in due parti: l’insieme
S = {v ∈ V | wv · r ≥ 0}
dei vertici rappresentati da punti nella semisfera superiore e l’insieme complementare
S = {v ∈ V | wv · r < 0}
dei vertici rappresentati da punti nella semisfera inferiore (i vertici sull’iperpiano
li mettiamo convenzionalmente in S).
In questo modo r individua un taglio (S, S) e siccome r e` scelto casualmente
possiamo scrivere il valore atteso del taglio come
Pr[segno(wu · r) = segno(wv · r)]
E[δ(S)] =
(2.6)
uv∈E
dove il valore atteso e` calcolato rispetto alla scelta casuale di r.
Lemma 2.5.1 Pr[segno(wu · r) = segno(wv · r)] =
arccos(wu · wv )
π
Dimostrazione. Ci limitiamo a dare una dimostrazione geometrica. La dimostrazione analitica e` pi`u complicata ed e` strettamente legata al problema della scelta
casuale di un punto r sulla superfice della sfera unitaria.
Sia Pw(2)
il piano bidimensionale che contiene i due vettori wu e wv e sia
u ,wv
α = arccos(wu · wv ) l’angolo tra i due vettori (vedi Figura 2.14).
(n−1)
Sia inoltre P⊥r il piano (n−1)-dimensionale perpendicolare ad r e passante
per l’origine.
130
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
y
z
r
wu
α
wv
x
α
α r
Pw(2)
u ,wv
(n−1)
P⊥r
Figura 2.14: Illustrazione del Lemma 2.5.1
(n−1)
Il piano P⊥r separa wu da wv se e solo se la retta di intersezione R dei due
.
piani separa wu da wv nel piano Pw(2)
u ,wv
se e solo se la proieA sua volta la retta R separa wu da wv nel piano Pw(2)
u ,wv
(2)
zione r di r sul piano Pwu ,wv appartiene ad uno di due settori opposti di ampiezza
α (vedi Figura 2.14).
Siccome il punto r e` scelto casualmente sulla superfice della sfera la probabilit`a che la sua proiezione r cada in uno dei due settori di ampiezza α e`
2α
arccos(wu · wv )
=
2π
π
Per il Lemma precedente possiamo riscrivere l’equazione 2.6
E[δ(S)] =
uv∈E
arccos(wu · wv )
π
2.5. PROBLEMA DEL TAGLIO MASSIMO
131
Siccome E[δ(S)] ≤ δ(Smax ) per ogni S, anche
max E[δ(S)] ≤ δ(Smax )
w1 ,...,wn
dove il massimo e` preso su tutte le possibili scelte dei vettori unitari w1 , . . . , wn
che rappresentano i vertici.
In realt`a tale massimo e` uguale a δ(Smax ). Infatti supponiamo che tutti i vettori
relativi ai vertici in Smax siano uguali ad un vettore unitario w e tutti i vettori
relativi ai vertici in S max siano uguali al vettore opposto −w. In questo caso, tutti
i valori di r generano lo stesso taglio Smax e quindi E[δ(S)] = δ(Smax ).
Questo dimostra che
δ(Smax ) = max
w1 ,...,wn
uv∈E
arccos(wu · wv )
π
Sfortunatamente trovare questo massimo e` difficile almeno quanto il problema
originale e quindi pu`o sembrare che non abbiamo fatto alcun progresso. Possiamo
per`o approssimare tale massimo scegliendo opportunamente un insieme di vettori.
2.5.2
Come scegliere un buon insieme di vettori
La funzione
arccos(x)
π
e` definita nell’intervallo [−1, 1] e assume valori in [0, 1] con f (1) = 0 ed f (−1) =
1.
Possiamo ottenere un rilassamento sostituendo la funzione f (x) con una qualsiasi altra funzione g(x) definita in [0, 1] e tale che g(1) = 0 ed g(−1) = π.
Consideriamo infatti il seguente problema P di programmazione non lineare:
f (x) =
g(wu · wv )
CP = max
uv∈E
wu
= 1
∀u ∈ V
Se, dato un taglio S, poniamo wu = w se u ∈ S e wu = −w altrimenti, otteniamo
g(wu · wv ) = δ(S)
uv∈E
Quindi CP ≥ δ(Smax ) e` un limite superiore per il valore del taglio massimo.
132
2.5.3
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
L’algoritmo
L’algoritmo si compone dei seguenti tre passi:
1. Risolvi il problema P per ottenere un insieme di vettori {w1∗ , . . . , wn∗ }.
2. Scegli casualmente il vettore unitario r.
3. Poni S = {u | wu∗ · r ≥ 0}.
Per il taglio S calcolato in questo modo vale il seguente
Teorema 2.5.2 E[δ(S)] ≥ α CP ≥ α δ(Smax ) dove α = min
−1≤x≤1
f (x)
.
g(x)
Dimostrazione. Basta osservare che
arccos(wu∗ · wv∗ )
f (wu∗ · wv∗ )
=
E[δ(S)] =
π
uv∈E
uv∈E
αg(wu∗ · wv∗ )
≥
uv∈E
= α CP ≥ α δ(Smax )
Dobbiamo quindi scegliere la funzione g in modo tale che il programma P sia
risolubile in tempo polinomiale e che α risulti pi`u grande possibile.
Vedremo che se g e` lineare il problema P si pu`o risolvere in tempo polinomiale. Scegliamo quindi g(x) = 21 (1 − x): la funzione lineare tale che g(−1) = 1 e
g(1) = 0. Con questa scelta
2 arccos(x)
−1≤x≤1 π(1 − x)
2 arccos(−0.689)
=
π(1 + 0.689)
= 0.87856
α =
2.5.4
min
Soluzione di P
Avendo scelto g(x) = 12 (1 − x) dobbiamo risolvere il seguente problema P di
programmazione non lineare
CP = max
uv∈E
wu
= 1
1
(1 − wu · wv )
2
∀u ∈ V
(2.7)
2.5. PROBLEMA DEL TAGLIO MASSIMO
133
Sia W la matrice avente per righe i vettori wu e sia Y = [yuv ] = W W T la matrice
n × n di elementi yuv = wu · wv . La matrice Y = [yuv ] soddisfa le seguenti
condizioni
1. yuu = wu · wu = ||wu || = 1.
2. Y
0, dove 0 significa che Y e` semi-definita positiva, ossia xT Y x ≥ 0
per ogni vettore x. Infatti
xT Y x =
(wu · wv )xv
xu
u
v
xu w u ·
=
u
xv w v
v
xu w u ≥ 0
=
u
Viceversa, ogni matrice semidefinita positiva Y
0 tale che yuu = 1 per ogni
u pu`o essere scritta come Y = [wu ·wv ] per un opportuno insieme di vettori unitari
{w1 , . . . , wn }. Questo si ottiene con la fattorizzazione di Cholesky Y = W W T .
Quindi il problema 2.7 e` equivalente al seguente
CP = max
uv∈E
Y
yuu
0
= 1
1
(1 − yuv )
2
(2.8)
∀u ∈ V
Osserviamo che l’insieme Qn delle matrici n × n semidefinite positive con
yuu = 1 per ogni u e` un insieme convesso. Infatti se A, B ∈ Qn allora anche
tA + (1 − t)B ∈ Qn
per 0 ≤ t ≤ 1 come si pu`o facilmente verificare.
La funzione obiettivo e` invece concava (`e lineare). Possiamo quindi risolvere
in tempo polinomiale il problema 2.8 utilizzando un algoritmo di programmazione
convessa.
Questo completa l’analisi dell’algoritmo.
Osserviamo che l’analisi e` molto stretta: se il grafo G e` un ciclo con 5 vertici
allora δ(Smax ) = 4 e
√
π
25 + 5 5
5
CP = (1 + cos ) =
2
5
8
134
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
per cui
δ(Smax )
24
√ = 0.88445
=
CP
25 + 5 5
2.5.5
Come scegliere r
Il vettore unitario r deve essere scelto casualmente sulla sfera unitaria n-dimensionale F (n) .
Per scegliere casualmente il vettore unitario r basta scegliere casualmente un
vettore n-dimensionale x con una qualsiasi distribuzione di probabilit`a che sia
invariante per rotazione e dividerlo per la sua lunghezza |x| = x21 + . . . + x2n
per ottenere il vettore unitario r = x/|x|.
Il seguente Teorema ci dice come possiamo fare ci`o in modo semplice:
Teorema 2.5.3 Sia x = (x1 , . . . , xn ) una variabile casuale vettoriale e supponiamo che le sue coordinate xi siano scelte casualmente ed indipendentemente
da una distribuzione di probabilit`a normale N (0, 1) con media 0 e varianza 1.
Allora la probabilit`a p(x) di x e` invariante per rotazione.
Dimostrazione. La probabilit`a della normale N (0, 1) e` :
1
2
p(z) = √ e−z /2
2π
E quindi
1
1
1
2
2
2
p(x) = √ e−x1 /2 · √ e−x2 /2 · . . . · √ e−xn /2
2π
2π
2π
n
1
2
2
√
e−(x1 +...+xn )/2
=
2π
n
1
√
=
e−||x||/2
2π
dove
||x|| = xT x = x21 + . . . + x2n
e` la norma quadratica di x. Siccome la norma di un vettore non cambia se il
vettore viene ruotato, anche la probabilit`a p(x) e` invariante per rotazione.
2.6. SCHEMI DI APPROSSIMAZIONE
2.6
135
Schemi di approssimazione
Possiamo andare un po’ pi`u avanti con il concetto di algoritmo di approssimazione
per definire il concetto di schema di approssimazione.
Definizione 2.6.1 Uno schema di approssimazione polinomiale PAS e` una famiglia di algoritmi A = {Aε : ε > 0} tali che per ogni ε > 0 l’algoritmo Aε e` un
algoritmo di (1 + ε)-approssimazione.
Definizione 2.6.2 Uno schema di approssimazione totalmente polinomiale FPAS
e` un PAS tale che Aε richiede tempo polinomiale sia nella dimensione dell’input
che in 1ε .
Come risultati negativi abbiamo visto che, per i risultati di Arora, i problemi
in MAX-SNP non hanno PAS (a meno che P = NP). Si sa inoltre che i problemi
NP-completi forti, non hanno FPAS (a meno che P = NP). Un problema NPcompleto forte e` un problema di decisione NP-completo avente degli interi come
input e che rimane NP-completo anche se imponiamo la restrizione che ogni numero in input si possa rappresentare con O(log(n)) bit, dove n e` la dimensione
dell’input.
Vediamo ora due problemi di ottimizzazione molto simili, tanto che il problema di decisione ad essi associato e` esattamente lo stesso, ma che si comportano in
modo molto diverso rispetto all’approssimabilit`a: uno ha un PAS e l’altro no.
Impacchettamento: Dato un insieme O = {o1 , . . . , on } di n oggetti rispettivamente di dimensioni d1 , . . . , dn e dei contenitori tutti uguali di capacit`a C
calcolare una partizione O1 , . . . , Om di O nel minimo numero m di sottoinsiemi tali che ciascuno dei sottoinsiemi possa essere contenuto in uno dei
contenitori di capacit`a C, ossia tali che
dj ≤ C
Cmax = max
1≤i≤m
oj ∈Oi
Schedulazione: Dato un insieme O = {o1 , . . . , on } di n lavori con tempi di esecuzione d1 , . . . , dn ed m macchine M1 , . . . , Mm su cui eseguirli calcolare
una partizione di O in sottoinsiemi O1 , . . . , Om che minimizzi
Cmax = max
1≤i≤m
dj
oj ∈Oi
ossia una ripartizione dei lavori tra le m macchine che permetta di terminare
tutti i lavori nel minimo tempo possibile.
136
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
La differenza tra i due problemi e` che nell’impacchettamento e` dato un limite
superiore C per Cmax ed e` richiesto di minimizzare il numero di sottoinsiemi m
mentre nella schedulazione e` fissato il numero di sottoinsiemi m ed e` richiesto di
minimizzare il limite superiore Cmax .
Il problema di decisione, in cui e` fissato sia m che C e si chiede se esiste una
partizione che soddisfi la disequazione, e` chiaramente lo stesso per entrambi ed e`
NP-completo.
Se consideriamo algoritmi di approssimazione abbiamo risultati completamente diversi per i due problemi. Per il problema dell’impacchettamento non
esiste alcun algoritmo di α-approssimazione con α < 32 (a meno che P = NP)
come abbiamo visto nella Sezione 2. Invece, per il problema della schedulazione
esiste un algoritmo di α-approssimazione per ogni α.
2.6.1
Schemi di approssimazione asintotici
Consideriamo una istanza
I = (n, m, d1 , . . . , dn )
del problema di schedulazione. Sia CO PT (I) il tempo minimo necessario ad eseguire tutti gli n lavori sulle m macchine. Per ogni C ≥ 0, sia IC l’insieme delle
istanze I per cui CO PT (I) = C.
Dato un algoritmo di approssimazione A che calcola una soluzione approssimata di valore CA (I) ed un valore C ≥ 0 possiamo considerare il coefficiente di
approssimazione peggiore sull’insieme IC di istanze, ossia
α(C) = sup
I∈IC
CA (I)
C
Definizione 2.6.3 Diciamo che l’algoritmo A ha rapporto di approssimazione
asintotico α se
α ≥ lim sup α(C)
C→∞
dove sup α(C) e` l’estremo superiore dell’insieme {α(C ) : C ≥ C}.
In Figura 2.15 e` rappresentato un possibile andamento delle funzioni α(C) e
sup α(C).
Per il problema della schedulazione non vi e` alcuna differenza tra rapporto
di approssimazione asintotico e rapporto di approssimazione. Questo perch´e il
2.6. SCHEMI DI APPROSSIMAZIONE
137
α
C
Figura 2.15: Grafico di α(C) (in nero) e di sup α(C) (in rosso dove differisce da
α(C)). Il valore di α = limC→∞ sup α(C) e` indicato in rosso tratteggiato.
problema della schedulazione gode della propriet`a di scalabilit`a: data una istanza
I ∈ IC possiamo costruire un’istanza I ∈ IβC semplicemente moltiplicando
tutti i tempi di esecuzione per β. Quindi per il problema della schedulazione
α(C) = sup α(C) = costante.
Usando la definizione precedente possiamo definire il concetto di schema di
approssimazione asintotico polinomiale PAAS e quello di schema di approssimazione asintotico totalmente polinomiale FPAAS .
Riassumiamo alcuni risultati che illustrano le differenze tra i due problemi.
1. Per l’impacchettamento non esiste alcun algoritmo di α-approssimazione
con α < 23 , a meno che P = NP. Dunque non esiste alcun PAS per
l’impacchettamento (a meno che P = NP).
2. Per la schedulazione esiste un PAS (Hochbaum e Shmoys [15]) che illustreremo tra poco.
3. Per l’impacchettamento esiste un PAAS (Fernandez de la Vega e Lueker
[9]).
4. Per la schedulazione non esiste alcun FPAAS a meno che P = NP. Questo
perch´e l’esistenza di un FPAAS implica l’esistenza di un FPAS (per la
scalabilit`a) e l’esistenza di un FPAS e` esclusa (a meno di P = NP) in
quanto la schedulazione e` un problema NP-completo forte.
5. Per l’impacchettamento esiste anche un FPAAS (Karmarkar e Karp [16]).
138
2.6.2
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Uno schema di approssimazione per la schedulazione
Presentiamo uno schema di approssimazione polinomiale per il problema della
schedulazione. Questo schema e` dovuto a Hochbaum e Shmoys [15].
L’idea e` quella di usare una relazione simile a quella che esiste tra un problema
di ottimizzazione ed il problema di decisione associato: se abbiamo un modo per
risolvere il problema di decisione, possiamo usare la ricerca binaria per trovare la
soluzione del problema di ottimizzazione.
Noi otterremo un algoritmo di (1 + ε)-approssimazione per il problema di
ottimizzazione usando un algoritmo di (1 + ε)-approssimazione per il problema
di decisione associato.
Ma cosa significa algoritmo di (1 + ε)-approssimazione per un problema di
decisione se il risultato pu`o essere soltanto SI o NO? La definizione e` la seguente:
Definizione 2.6.4 Un algoritmo di (1 + ε)-approssimazione per un problema di
decisione e` un algoritmo polinomiale che dato C risponde SI se C ≥ CO PT , risponde NO se C < CO PT /(1 + ε) mentre se CO PT /(1 + ε) ≤ C < CO PT pu`o rispondere
sia SI che NO. In ogni caso se l’algoritmo risponde SI esso deve fornire in output
anche una soluzione di costo C ∗ minore o uguale di (1 + ε)C.
Se abbiamo a disposizione un algoritmo di (1 + ε)-approssimazione per il problema di decisione associato possiamo usare la ricerca binaria per trovare una soluzione (1 + ε)-approssimata per il problema della schedulazione. Per fare questo
si procede nel modo seguente.
Per iniziare la ricerca binaria ci serve intanto un intervallo che contenga il
valore CO PT . Allo scopo consideriamo il massimo tra il carico medio per macchina
Cmed ed il tempo massimo dmax richiesto per un singolo lavoro
L = max(Cmed , dmax ) = max
n
i=1
m
di
, max di
1≤i≤n
Siccome tutti i lavori devono essere eseguiti valgono le due disuguaglianze
CO PT ≥ dmax e CO PT ≥ Cmed . Quindi L e` un limite inferiore per CO PT .
Mostriamo che 2L e` un limite superiore per CO PT . Consideriamo una schedulazione in cui i lavori vengono eseguiti nell’ordine o1 , o2 , . . . , on sulla prima
macchina che si libera.
Sia oi un lavoro che finisce per ultimo al tempo C ∗ . Fino al tempo Ci in cui e`
iniziata l’esecuzione di oi tutte le macchine hanno lavorato continuamente. Quindi
Ci ≤ Cmed (vedi Figura 2.16). Dunque
CO PT ≤ C ∗ = Ci + di ≤ Cmed + dmax ≤ 2L
2.6. SCHEMI DI APPROSSIMAZIONE
m
..
.
k
..
.
139
..
.
oi
..
.
1
Ci
Cmed C ∗
Figura 2.16: Schedulazione dei lavori o1 , o2 , . . . , on
ed abbiamo l’intervallo [L, 2L] da cui partire per una ricerca binaria del valore
ottimo CO PT .
Partiamo quindi con l’intervallo di estremi C1 = L e C2 = 2L e lo restringiamo in modo da mantenere vero che C1 ≤ CO PT e che esiste una schedulazione di
costo C ∗ ≤ (1 + ε/2)C2 (e quindi a maggior ragione CO PT ≤ (1 + ε/2)C2 ).
Noi effettueremo la ricerca binaria usando una scala logaritmica. Il punto
medio in scala logaritmica tra i due estremi C1 e C2 e` quel valore C per cui
log2 C =
log2 C1 + log2 C2
2
√
ovvero C = C1 C2 (detta anche media geometrica).
Partiamo quindi con l’intervallo
√ di estremi C1 = L e C2 = 2L, calcoliamo la media geometrica C = C1 C2 ed eseguiamo l’algoritmo di (1 + ε/2)approssimazione per il problema di decisione con input il valore C.
Se la risposta e` NO sappiamo che C ≤ CO PT e ci restringiamo all’intervallo
[C, C2 ]. Se la risposta e` SI sappiamo che esiste una schedulazione di costo C ∗ ≤
(1 + ε/2)C e ci restringiamo all’intervallo [C1 , C].
Continuiamo il procedimento fino a che l’intervallo si restringe abbastanza da
rendere vera la diseguaglianza
C2
1+ε
≤
C1
1 + ε/2
ovvero l’ampiezza dell’intervallo in scala logaritmica si riduce a
log2 C2 − log2 C1 ≤ log2 (1 + ε) − log2 (1 + ε/2)
140
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
All’inizio tale ampiezza e` log2 2L
= 1 e ad ogni iterazione viene dimezzata.
L
Dunque il numero di iterazioni necessario per raggiungere la condizione di
uscita e` il minimo i tale che
1
≤ log2 (1 + ε) − log2 (1 + ε/2)
2i
ossia



i=
log2


1
log2
1+ε
1+ε/2



Siccome ci interessa il comportamento asintotico rispetto a 1/ε possiamo assumere ε ≤ 1 per cui:
log2
1
1+ε
=
[ln(1 + ε) − ln(1 + ε/2)]
1 + ε/2
ln 2
∞
1
1
1 ∞
(−1)i+1 εi − (−1)i+1 (ε/2)i
=
ln 2 i=1
i
i
i=1
i
1 ∞
i+1 2 − 1 i
=
(−1)
ε
ln 2 i=1
i2i
=
∞
2i − 1 i
3
1 1
ε − ε2 + (−1)i+1
ε
ln 2 2
8
i2i
i=3
≥
1 1
3
ε − 3(ε/2)2
ε − ε2 =
ln 2 2
8
2 ln 2
e il numero di iterazioni e`
i ≤ log2
2 ln 2
ε − 3(ε/2)2
= O log
1
ε
Notiamo che O(log 1ε ) = O(1) e` costante per un ε prefissato.
Alla fine delle iterazioni abbiamo
C ∗ ≤ (1 + ε/2)C2 ≤ (1 + ε)C1 ≤ (1 + ε)CO PT
L’algoritmo restituisce quindi il valore C ∗ che differisce dal valore ottimo CO PT
per un fattore minore o uguale ad 1 + ε. Esso restituisce inoltre una schedulazione
di costo C ∗ . Se C2 = 2L e` rimasto invariato la schedulazione e` quella banale
usata per dimostrare che 2L e` un limite superiore. Se C2 < 2L la schedulazione e`
2.6. SCHEMI DI APPROSSIMAZIONE
ρC
q i di
t0 t1 t2
tj
141
C
tK
Figura 2.17: La discretizzazione delle durate dei lavori lunghi. I punti di discretizzazione sono tj = ρC + jρ2 C. Ad ogni durata di corrisponde una durata discretizzata qi il cui valore e` il punto di discretizzazione tj immediatamente
precedente.
quella di costo C ∗ calcolata dall’algoritmo di approssimazione per il problema di
decisione quando ha posto C2 = C.
Rimane soltanto da trovare l’algoritmo di (1 + ε)-approssimazione per il problema di decisione.
L’intuizione ci dice che i maggiori problemi nella schedulazione si hanno con
i lavori lunghi. I lavori corti si possono facilmente accomodare. Dividiamo quindi
l’insieme O dei lavori in due gruppi Ocorti ed Olunghi mettendo in Ocorti tutti i
lavori di durata di ≤ ρC, con ρ = ε/2.
Troviamo dapprima un algoritmo di (1 + ρ)-approssimazione per il problema
di decisione relativo ai soli lavori lunghi Olunghi che fornisca, in caso di risposta
positiva, una schedulazione di tali lavori che richiede tempo massimo (1+ρ)CO PT .
Dopo di che vedremo come sia possibile aggiungere i lavori corti Ocorti in
modo da rispettare il limite globale (1 + ε)CO PT .
Vediamo nel dettaglio come si effettuano queste operazioni.
Per schedulare i lavori lunghi in tempo massimo (1 + ρ)C osserviamo che vi
e` un numero massimo
N≤
1+ρ
(1 + ρ)C
=
= O(1/ρ) = O(1/ε)
ρC
ρ
di lavori lunghi che possono essere eseguiti su di una singola macchina e che tale
numero dipende soltanto da ε e non dalla particolare istanza del problema.
Operiamo inoltre una discretizzazione (Figura 2.17) della scala dei tempi compresi tra ρC e C ponendo
tj = ρC + jρ2 C
ed arrotondiamo le durate di dei lavori lunghi al valore discreto qi immediatamente
precedente, ossia
qi = tj ≤ di < tj+1
142
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Le durate discretizzate possono assumere al pi`u K valori distinti, dove K e`
l’intero tale che tK−1 ≤ C < tK , ossia
K = 1+
1−ρ
= O(1/ρ2 ) = O(1/ε2 )
2
ρ
Quindi anche K dipende soltanto da ε e non dalla particolare istanza del problema
e dunque, per un ε prefissato, sia N che K sono delle costanti.
Come vedremo tra poco esiste un algoritmo polinomiale che risolve (in modo
esatto) il problema di decisione con durate discretizzate.
Lemma 2.6.5 Se l’algoritmo di decisione con durate discretizzate ritorna NO non
esiste nessuna schedulazione dei lavori lunghi con durate originali avente tempo
di fine minore o uguale a C (e quindi neppure di tutti i lavori sia lunghi che corti).
Se l’algoritmo di decisione con durate discretizzate ritorna SI esiste una schedulazione dei lavori lunghi con durate originali avente tempo di fine minore o
uguale di (1 + ρ)C.
Dimostrazione. Nel primo caso la cosa e` ovvia in quanto le durate discretizzate
qi sono minori o uguali delle corrispondenti durate originali di .
Supponiamo quindi che esista una schedulazione che esegue tutti i lavori lunghi con durate discretizzate in tempo C.
Siccome le durate discretizzate sono tutte maggiori o uguali di ρC, su ogni
macchina vengono eseguiti al pi`u ρ1 lavori.
La differenza tra una durata effettiva e quella discretizzata e` al pi`u ρ2 C e quindi
l’aumento totale del tempo di fine di tutti i lavori e` al pi`u
1 2
ρ C = ρC
ρ
Dunque il tempo di fine con le durate originali e` al pi`u (1 + ρ)C.
Per risolvere il problema di decisione con durate discretizzate sfruttiamo il
fatto che esso e` anche il problema di decisione associato al problema dell’impacchettamento.
Useremo quindi la programmazione dinamica applicata al problema dell’impacchettamento per calcolare il minimo numero m di macchine necessarie ad
eseguire tutti i lavori lunghi con durate discretizzate entro il tempo C. Se m ≤ m
si risponde SI altrimenti si risponde NO.
2.6. SCHEMI DI APPROSSIMAZIONE
143
Rimane soltanto da mostrare come si possa usare la programmazione dinamica per risolvere il problema dell’impacchettamento sui lavori lunghi con durate
discretizzate.
Osserviamo intanto che l’istanza del problema dell’impacchettamento e` molto
particolare: abbiamo un numero massimo N costante di lavori su di una singola
macchina ed un numero massimo K costante di durate distinte.
Sia ni il numero di lavori lunghi aventi durata discretizzata qi per cui
K
n=
ni
i=1
Possiamo rappresentare i lavori lunghi eseguiti su di una singola macchina
con una sequenza (r1 , . . . , rK ) dove ri ≤ ni indica il numero di lavori di durata
discretizzata qi eseguiti su tale macchina.
Naturalmente ni ≤ N e quindi vi sono al pi`u N K tali sequenze. Possiamo
quindi enumerale tutte per selezionare l’insieme di quelle che rispettano il limite
C, ossia l’insieme
K
ri qi ≤ C
R = (r1 , . . . , rK ) :
i=1
Sia (r1 , . . . , rK ) ∈ R una sequenza che rispetta il limite C. Se eseguiamo tali
lavori su di una singola macchina ci occorrono almeno tante altre macchine quanto
e` il minimo per eseguire i rimanenti lavori, quelli rappresentati dalla sequenza
(n1 − r1 , . . . , nK − rK ).
Dunque, se indichiamo con m (n1 , . . . , nK ) il numero minimo di macchine
necessario ad eseguire i lavori lunghi con durate discretizzate rappresentati con la
sequenza (n1 , . . . , nK ) possiamo scrivere la relazione di ricorrenza
m (n1 , . . . , nK ) = 1 +
min
(r1 ,...,rK )∈R
m (n1 − r1 , . . . , nK − rK )
che si pu`o risolvere usando la programmazione dinamica.
Siccome le sequenze (n1 , . . . , nK ) sono meno di nK anche l’insieme dei sottoproblemi m (n1 , . . . , nK ) da risolvere con la programmazione dinamica ha cardinalit`a minore di nK e ciascuno di essi richiede di calcolare il minimo tra al pi`u
|R| ≤ N K valori calcolati precedentemente.
Dunque il tempo per risolvere la relazione di ricorrenza e`
2
2
2
O(nK N K ) = nO(1/ρ ) O(1/ρ)O(1/ρ ) = O(n/ρ)O(1/ρ ) = O(n/ε)O(1/ε
2)
144
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Usando la schedulazione dei lavori lunghi con durate discretizzate ottenuta con
la programmazione dinamica possiamo costruire l’algoritmo di (1 + ε)-approssimazione per il problema di decisione nel modo seguente.
Se la schedulazione ottima dei lavori lunghi con durate discretizzate ha valore
CO PT > C la schedulazione ottima di tutti i lavori con durate originale deve avere
costo ancora maggiore e quindi
CO PT ≥ CO PT > C
e l’algoritmo di decisione termina rispondendo NO.
Altrimenti l’algoritmo aggiunge uno alla volta i lavori corti alla schedulazione
attribuendo ciascuno di essi alla prima macchina che si libera e considerando i
tempi di esecuzione originali (vedi Figura 2.18).
CO PT CO PT
m
..
.
..
.
k
..
.
..
.
1
C
(1+ε)C
Figura 2.18: Schedulazione dei lavori corti
Se la schedulazione di tutti i lavori cos`ı ottenuta ha valore Cmax > (1 + ε)C
al tempo C tutte le macchine dovevano essere occupate (in quanto i lavori corti
hanno tutti durata di ≤ ρC < εC). Dunque
di ≥ mC
1≤i≤n
e i lavori non possono essere eseguiti tutti entro il tempo C. Anche in questo caso
l’algoritmo termina rispondendo NO. Altrimenti l’algoritmo termina rispondendo
SI e ritorna la schedulazione di costo Cmax ≤ (1 + ε)C calcolata. Questo costa
tempo O(n).
2.6. SCHEMI DI APPROSSIMAZIONE
145
2
Sommando il tempo O(n/ε)O(1/ε ) per calcolare m (n1 , n2 , . . . , nK ), si ottiene
un tempo
2
O(n + (n/ε)O(1/ε ) )
per risolvere il problema di decisione (1 + ρ)-rilassato.
Siccome tale soluzione deve essere iterata O(log 1ε ) volte per effettuare la
ricerca binaria otteniamo un tempo totale
1
2
O(n + (n/ε)O(1/ε ) )O(log )
ε
per l’intero algoritmo. Per ogni prefissato ε tale tempo e` polinomiale in n. Abbiamo quindi ottenuto un PAS per il problema della schedulazione.
146
CAPITOLO 2. ALGORITMI DI APPROSSIMAZIONE
Bibliografia
[1] S.Arora, C.Lund, R.Motwani, M.Sudan, M.Szegedy. Proof verification and
hardness of approximation problems. In Proceedings of the 33th Annual
Symposium on Foundation of Computer Science, pages 14–23, 1992.
[2] S.Arora, S.Safra. Probabilistic checking of proofs. In Proceedings of the
33th Annual Symposium on Foundation of Computer Science, pages 2–13,
1992.
[3] R.Bar-Yehuda, S.Even. A linear time approximation algorithm for the
weighted vertex cover problem. Journal of Algorithms, 2:198-203, 1981.
[4] M.Bellare, M.Sudan. Improved non-approximability results. In Proceedings
of the 26th Annual ACM Symposium on Theory of Computing, pages 184193, 1994.
[5] N.Christofides. Worst-case analysis of a new heuristic for the travelling
salesman problem. Tecnical Report 388, Graduate School of Industrial
Administration, Carnegie Mellon University, Pittsburgh, PA, 1976.
[6] I.Dinur, The PCP theorem by gap amplification. In Proceedings 38th ACM
Symposium on Theory of Computing, pages 241-250, 2006.
[7] J.Edmonds. Maximum matching and a polyhedron with 0,1-vertices. Journal of Research of the National Bureau of Standards B, 69B:125-130,
1965.
[8] R.Fagin. Generalized first-order spectra, and polynomial-time recognizable
sets. In R. Karp, editor, Complexity of Computations, AMS, 1974.
[9] W.Fernandez de la Vega, G.S.Luecker. Bin packing can be solved in within
(1 + ) in linear time. Combinatorica, 1(4), 1981.
147
148
BIBLIOGRAFIA
[10] N.H.Gabow. Data structures for weighted matching and nearest common
ancestors with linking. In Proceedings of the 1st ACM-SIAM Symposium on
Discrete Algorithms, pages 434-443, 1990.
[11] N.H.Gabow, M.X.Goemans, D.P.Williamson. An efficient approximation
algorithm for the survivable network design problem. In Proceedings of
the Third MPS Conference on Integer Programming and Combinatorial
Optimization, pages 57-74, 1993.
[12] M. X. Goemans, D. P. Williamson. A general approximation technique for
constrained forest problems. In Proceedings of the 3rd ACM-SIAM Symposium on Discrete Algorithms, pages 307-316, 1992.
[13] M. X. Goemans, D. P. Williamson. Improved approximation algorithms
for maximum cut and satisfiability problems using semidefinite programming. In Proceedings of the 26rd Annual ACM Symposium on Theory of
Computing, pages 422-431, 1994.
[14] D.Hochbaum. Approximation algorithms for set covering and vertex cover
problems. SIAM Journal on Computing, 11:555-556, 1982.
[15] D.Hochbaum and D.Shmoys. Using dual approximation algorithms for scheduling problems: theoretical and practical results. Journal of the ACM,
34(1), Jan. 1987.
[16] N.Karmarkar, R.Karp. An efficient approximation scheme for the onedimensional bin-packing problem. In Proceedings of the 23rd Annual
Symposium on Foundation of Computer Science, 1982.
[17] C.H.Papadimitriou, M.Yannakakis. Optimization, approximation, and complexity classes. Journal of Computer and Systems Science, 43:425–440,
1991.
[18] S. Ben-David, A. Borodin, R. M. Karp, G. Tardos, and A. Wigderson. On
the power of randomization in on-line algorithms. Algorithmica, 11:2–14,
1994.
[19] M. Chrobak and L. L. Larmore. On fast algorithms for two servers. Journal
of Algorithms, 12:607–614, 1991.
BIBLIOGRAFIA
149
[20] M. Chrobak and L. L. Larmore. An optimal online algorithm for k servers
on trees. SIAM Journal on Computing, 20:144–148, 1991.
[21] M. Chrobak and L. L. Larmore. HARMONIC is three-competitive for two
servers. Theoretical Computer Science, 98:339–346, 1992.
[22] M. Chrobak and L. L. Larmore. The server problem and on-line games. In
DIMACS Series in Discrete Mathematics and Theoretical Computer Science,
volume 7, pages 11–64, 1992.
[23] D. Coppersmith, P. G. Doyle, P. Raghavan and M. Snir. Random walks on
weighted graphs and applications to on-line algorithms. Journal of the ACM,
40:421–453, 1993.
[24] A. Fiat, R. Karp, M. Luby, L. A. McGeoch, D. Sleator, and N. E. Young.
Competitive paging algorithms. Journal of Algorithms, 12:685–699, 1991.
[25] A. Fiat, Y. Rabani, and Y. Ravid. Competitive k-server algorithms. In
Proc. 31st Symp. Foundations of Computer Science (FOCS), pages 454–463.
IEEE, 1990.
[26] E. Grove. The harmonic k-server algorithm is competitive. In Proc. 23rd
Symp. Theory of Computing (STOC), pages 260–266. ACM, 1991.
[27] S. Irani and R. Rubinfeld. A competitive 2-server algorithm. Information
Processing Letters, 39:85–91, 1991.
[28] D. S. Johnson. Fast algorithms for bin packing. Journal Computer Systems
Science, 8:272–314, 1974.
[29] J. M. Kleinberg. The localization problem for mobile robots. In Proc. 35th
Symp. Foundations of Computer Science (FOCS), pages 521–531. IEEE,
1994.
[30] E. Koutsoupias and C. Papadimitriou. On the k-server conjecture. Journal
of the ACM, 42:971–983, 1995.
[31] E. Koutsoupias. Weak adversaries for the k-server problem. In Proc. 40th
Symp. Foundations of Computer Science (FOCS), pages 444–449, 17–19
October 1999.
150
BIBLIOGRAFIA
[32] M. Manasse, L. A. McGeoch, and D. Sleator. Competitive algorithms for
server problems. Journal of Algorithms, 11:208–230, 1990.
[33] L. McGeoch and D. Sleator. A strongly competitive randomized paging
algorithm. Algorithmica, 6(6):816–825, 1991.
[34] P. Raghavan and M. Snir. Memory versus randomization in online algorithms. In Proc. 16th International Colloquium on Automata, Languages, and
Programming (ICALP), volume 372 of Lecture Notes in Computer Science,
pages 687–703. Springer, 1989.
[35] D. Sleator and R. E. Tarjan. Amortized efficiency of list update and paging
rules. Communications of the ACM, 28:202–208, 1985.
[36] A. C. C. Yao. New algorithms for bin packing. Journal of the ACM, 27:207–
227, 1980.
Indice
1
Algoritmi on-line
1.1 Introduzione . . . . . . . . . . . . . . . . . . . . .
1.1.1 Problema dell’investimento . . . . . . . .
1.1.2 Problema del noleggio degli sci . . . . . .
1.2 Problema della paginazione . . . . . . . . . . . . .
1.3 Algoritmo off-line di paginazione ottimo . . . . . .
1.4 Limite inferiore per la competitivit`a . . . . . . . .
1.5 Algoritmi on-line randomizzati . . . . . . . . . . .
1.6 Analisi dell’algoritmo M ARKING . . . . . . . . .
1.6.1 Costo prima pagina stabile . . . . . . . . .
1.6.2 Limite superiore su una fase . . . . . . . .
1.6.3 Limite inferiore su una fase . . . . . . . .
1.6.4 Il rapporto di competitivit`a di M ARKING .
1.7 Un limite inferiore per algoritmi randomizzati . . .
1.7.1 Un’utile tecnica . . . . . . . . . . . . . . .
1.7.2 Applicazione al problema della paginazione
1.8 Tipi di avversari . . . . . . . . . . . . . . . . . . .
1.9 Competitivit`a contro i vari tipi di avversari . . . . .
1.10 Analisi dell’algoritmo R ANDOM . . . . . . . . . .
1.11 Problema dei k server . . . . . . . . . . . . . . . .
1.11.1 Casi particolari . . . . . . . . . . . . . . .
1.11.2 Risultati noti . . . . . . . . . . . . . . . .
1.11.3 Alcune semplici strategie. . . . . . . . . .
1.12 Un algoritmo k competitivo sugli alberi . . . . . .
1.12.1 Dimostrazione della k-competitivit`a . . . .
1.13 Spazi metrici resistivi . . . . . . . . . . . . . . . .
1.13.1 L’algoritmo RWALK . . . . . . . . . . . .
151
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
5
5
6
7
11
15
16
19
22
23
24
25
25
25
27
30
32
36
39
40
41
42
44
45
50
54
152
INDICE
1.14 Algoritmo della funzione lavoro . . . . . . . . . . . . . . . . . . 60
1.14.1 La funzione lavoro . . . . . . . . . . . . . . . . . . . . . 61
1.14.2 L’algoritmo W ORK della funzione lavoro . . . . . . . . . 68
2
Algoritmi di Approssimazione
2.1 Introduzione . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Risultati negativi . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.1 Le classi P ed NP . . . . . . . . . . . . . . . . . . . . . .
2.2.2 Riduzione di 3Sat a 3Color . . . . . . . . . . . . . . . . .
2.2.3 Dimostrazioni “oltre ogni ragionevole dubbio” . . . . . .
2.2.4 Risultati negativi derivati dal Teorema PCP . . . . . . . .
2.2.5 Problemi M AX -S NP completi . . . . . . . . . . . . . . .
2.3 Progettazione di algoritmi di approssimazione . . . . . . . . . . .
2.3.1 Riferimento diretto alla soluzione ottima . . . . . . . . .
2.3.2 Stratificazione . . . . . . . . . . . . . . . . . . . . . . .
2.3.3 Utilizzo di un limite inferiore . . . . . . . . . . . . . . .
2.3.4 Rilassamento LP per Mvc . . . . . . . . . . . . . . . . .
2.3.5 Come usare il rilassamento . . . . . . . . . . . . . . . . .
2.4 Problema del matching perfetto di costo minimo . . . . . . . . . .
2.4.1 Una formulazione di Mpm come problema di programmazione lineare . . . . . . . . . . . . . . . . . . . . . . . .
2.4.2 Dalle foreste ai matching perfetti . . . . . . . . . . . . . .
2.4.3 L’algoritmo . . . . . . . . . . . . . . . . . . . . . . . . .
2.4.4 Un esempio di esecuzione dell’algoritmo . . . . . . . . .
2.4.5 Analisi dell’algoritmo . . . . . . . . . . . . . . . . . . .
2.4.6 Ultimo passo e correttezza . . . . . . . . . . . . . . . . .
2.4.7 Alcuni dettagli implementativi . . . . . . . . . . . . . . .
2.5 Problema del taglio massimo . . . . . . . . . . . . . . . . . . . .
2.5.1 Un algoritmo randomizzato di 0.878-approssimazione . .
2.5.2 Come scegliere un buon insieme di vettori . . . . . . . . .
2.5.3 L’algoritmo . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.4 Soluzione di P . . . . . . . . . . . . . . . . . . . . . . .
2.5.5 Come scegliere r . . . . . . . . . . . . . . . . . . . . . .
2.6 Schemi di approssimazione . . . . . . . . . . . . . . . . . . . . .
2.6.1 Schemi di approssimazione asintotici . . . . . . . . . . .
2.6.2 Uno schema di approssimazione per la schedulazione . . .
79
79
81
82
86
89
93
97
99
99
103
105
106
107
110
111
113
116
116
117
120
124
125
128
131
132
132
134
135
136
138
Author
Document
Category
Uncategorized
Views
1
File Size
740 KB
Tags
1/--pages
Report inappropriate content