Meccanismo VCG per il cammino minimo tra due nodi

Il problema del cammino minimo
tra 2 nodi in un grafo con archi
privati
Il problema dello shortest
path egoistico


Input: un grafo G=(V,E) biconnesso sugli
archi, in cui ogni arco corrisponde in modo
biunivoco ad un insieme di agenti egoisti, un
nodo sorgente s e un nodo destinazione t; il
tipo di un agente è il costo di utilizzo
dell’arco (quindi tipo > 0); la sua valutazione
è uguale al suo tipo;
SCF: un vero cammino minimo in G=(V,E,tipi)
tra s e t.
Meccanismo VCG

Il problema è utilitario  VCG-mechanism
M= <g(r), p(x)>:


g(r): calcola PG(s,t) in G=(V,E,r)
pe: Per ogni arco eE:
pe =j≠e vj(rj,x(r-e)) -j≠e vj(rj,x) cioè
pe =

{d
G-e(s,t)-(dG(s,t)-re)
0
se ePG(s,t)
altrimenti
Per ogni e  PG(s,t), dobbiamo calcolare
PG-e(s,t), ovvero il cammino minimo di
rimpiazzo in G-e =(V,E\{e},r-e) tra s e t
Cammino di rimpiazzo per e
s
PG-e(s,t)
2
4
5
5
12
3
PG(s,t)
6
e
2
10
5
t
Ipotesi di lavoro



n=|V|, m=|E|
dG(s,t): distanza in G da s a t (somma dei pesi
degli archi di PG(s,t))
I nodi s,t sono 2-edge connessi: cioè, esistono
in G almeno 2 cammini tra s e t che sono
disgiunti sugli archi  per ogni arco e del
cammino PG(s,t) che viene rimosso esiste
almeno un cammino alternativo in G-e
…infatti, in caso contrario…
Se s,t non sono 2-edge connessi, c’è
almeno un arco in PG(s,t) che è un ponte
(arco che rimosso spezza G in due
componenti C1 e C2, r  C1 e s  C2)
 Se e è un ponte  dG-e(s,t) = ∞
 Il possessore di quell’arco “tiene in
pugno” il sistema: può chiedere qualsiasi
cifra!

Una soluzione banale
e PG(s,t) applichiamo l’algoritmo di
Dijkstra al grafo G-e
Complessità: k=O(n) archi per
O(m + n logn): O(mn + n2 logn) time
La soluzione che proponiamo costerà:
O(m + n logn) time
Notazioni




SG(s), SG(t): alberi dei cammini minimi
radicati in s e t
Ms(e): insieme dei nodi raggiungibili da
s in SG(s) senza passare per l’arco e
Ns(e)=V/Ms(e): nodi del sottoalbero di
SG(s) radicato in v, dove e=(u,v)
Mt(e), Nt(e) definiti in modo analogo
SG(s)
s
Ms(e)
u
e
v
t
Ns(e)
Crossing edges


Ms(e) e Ns(e) individuano un taglio in G
Cs(e)={(x,y) E\{e}: x Ms(e), yNs(e)}
archi del taglio: crossing edges
Crossing edges
SG(s)
s
Ms(e)
u
e
Cs(e)
v
t
Ns(e)
Come è fatto PG-e(s,t)?




Ovvio: non usa e
PG-e(s,t) deve attraversare il taglio
È il cammino più corto fra quelli che non
usano e
La sua lunghezza è:
dG-e(s,t)=
min
{dG-e(s,x)+w(f)+dG-e(y,t)}
f=(x,y)  Cs(e)
ove w(f) denota il peso dichiarato per f.
Cammino di rimpiazzo
s
u
x
e
v
y
dG-e(s,t)=
min
t
{dG-e(s,x)+w(f)+dG-e(y,t)}
f=(x,y)  Cs(e)
Come calcolare dG-e(s,t)

Sia f=(x,y)  Cs(e); dimostreremo che:
dG-e(s,x)+w(f)+dG-e(y,t)=dG(s,x)+w(f)+dG(y,t)
Osservazione: dG-e(s,x)=dG(s,x), perché x
Ms(e)
Lemma:
Sia f=(x,y)  Cs(e) un arco del taglio (x Ms(e)).
Allora y  Mt(e).
(da cui segue che: dG-e(y,t)=dG(y,t))
Un semplice lemma
Dim(per assurdo)
y Mt(e), allora y  Nt(e). Quindi y
discendente di u in SG(t) e PG(t,y) usa e.
PG(v,y) è sottocammino di PG(t,y). Quindi:
dG (v,y)=w(e) + dG (u,y) > dG (u,y).
y  Ns(e), allora PG(s,y) usa e. PG(u,y) è
sottocammino di PG(s,y). Quindi:
dG (u,y)=w(e) + dG (v,y) > dG (v,y).
s
Ms(e)
t
Ns(e)  Mt(e)
Costo per calcolare cammini di rimpiazzo
Dati SG(s) e SG(t), in tempo O(1) si può calcolare
k(f):= dG-e(s,x) + w(f) + dG-e(y,t)
dG(s,x)
dG(y,t)
guardo in SG(s) guardo in SG(t)
Osservazione: k(f) è la lunghezza del cammino minimo
fra s e t che usa f
Un altro semplice algoritmo
Passo 1: Calcoliamo SG(s) e SG(t)
Passo 2: e PG(s,t) guardiamo gli archi del taglio
Cs(e) e prendiamo il minimo (rispetto al valore
k(٠)).
Complessità
Passo 1: O(m + n logn)
Passo 2: k=O(n) archi, O(m) archi in ogni taglio:
O(mn)
Migliore di O(mn + n2 logn) se m=o(n logn)
L’algoritmo di Malik, Mittal e Gupta
(1989)


Alla fine degli anni ‘80, Malik et al. hanno risolto in
tempo O(m+n log n) il seguente problema di vitalità
su grafi: dato un cammino minimo PG(s,t), qual è il
suo arco più vitale, ovvero l’arco la cui rimozione
induce il più lungo cammino minimo di rimpiazzo tra
s e t?
Il loro approccio costruisce efficientemente tutti i
cammini di rimpiazzo tra s e t…
…ma questo è esattamente quello che stiamo
cercando nel nostro meccanismo VCG!
L’algoritmo di Malik, Mittal e Gupta





Siano e1, e2,…,ek gli archi di PG(s,t) da s verso t
Al passo i manteniamo in un heap H l’insieme dei
nodi Ns(ei) (convenzione: Ns(e0)=V)
Chiamiamo i nodi in H nodi attivi
Ad ogni nodo yH è associata una chiave k(y) e
un particolare crossing edge.
k(y)= min {dG(s,x)+w(x,y)+dG(y,t)}
x  Ms(ei)

k(y): lunghezza del cammino minimo da s a t
passante per y quando y è attivo
L’algoritmo di Malik , Mittal e
Gupta


Inizializzazione: H =V, k(y)= per ogni y
Passo i : consideriamo l’arco ei e processiamo H
nel seguente modo:




Elimino da H tutti i nodi in Ws(ei)=Ns(ei-1)\Ns(ei)
Considero ogni x  Ws(ei), quando trovo che un
vicino y a x è attivo, calcolo
k’(y)=dG(s,x)+w(x,y)+dG(y,t)
Se k’(y)<k(y) decremento k(y) a k’(y)
Processati tutti gli x  Ws(ei), estraggo il minimo da
H, che fornisce la lunghezza del cammino minimo di
rimpiazzo per ei (dG-ei(s,t))
Un esempio
s
Ws(e1)
e1
e2
e3
Ns(e1)
e4
e5
t
Un esempio
s
e1
e2
Ws(e2)
e3
e4
Ns(e2)
e5
t
Complessità computazionale di MMG
Teorema
Dati due nodi s,t in un grafo G con n
vertici e m archi, tutti i cammini di
rimpiazzo possono essere calcolati in
tempo O(m + n log n).
Complessità computazionale di MMG
Dim: Calcoliamo SG(s) e SG(t) in tempo O(m + n logn).
Usiamo l’heap di Fibonacci. Complessità
ammortizzata delle operazioni di delete e
delete_min è O(logn), e O(1) per le operazioni di
insert, find_min, decrease_key,make_heap.
Singola operazione make_heap
O(n) insert
O(n) find_min
O(m + n logn)
O(n) delete
O(m) decrease_key
Complessità computazionale del VCG
Corollario
Il meccanismo VCG per il problema del cammino
minimo può essere calcolato in tempo O(m + n
logn)
Dim
Complessità di g(٠): O(m + n logn)
Complessità di p(٠): calcolo tutte le distanze
dG-e(s,t), in tempo O(m + n logn)