Recupero del percorso più breve di un grafico dinamico

Attualmente sto studiando i percorsi più brevi nei grafici diretti. Esistono molti algoritmi efficienti per trovare il percorso più breve in una rete, come Dijkstra o Bellman-Ford. E se il grafico fosse dinamico? Dicendo dinamico intendo che possiamo inserire o rimuovere vertici durante l'esecuzione del programma. Sto cercando di trovare un algoritmo efficiente per aggiornare i percorsi più brevi da un vertice ad ogni altro vertice u , dopo aver inserito un bordo e , senza dover eseguire di nuovo l'algoritmo del percorso più breve nel nuovo grafico. Come posso fare questo? Grazie in anticipo.$v$$u$$e$

• Nota: le modifiche possono essere apportate dopo la prima iterazione dell'algoritmo
• Nota [2]: vengono indicati due nodi, l'origine e t l'obiettivo. Devo trovare il percorso più breve tra questi nodi. Quando il grafico viene aggiornato, devo solo aggiornare π ( s , t ) , che è il percorso più breve tra s e t .$s$$t$$\pi(s,t)$$s$$t$
• Nota [3]: sono interessato solo al caso di inserimento del bordo.

Una definizione formale : dato un grafico . Definire un'operazione di aggiornamento come 1) un inserimento di un bordo e di E o 2) aa delezione di un bordo e da E . L'obiettivo è trovare in modo efficiente il costo di tutte le coppie percorsi più brevi dopo un'operazione di aggiornamento. Con efficienza, intendiamo almeno meglio dell'esecuzione di un algoritmo All-Pairs-Shortest-Path, come l'algoritmo Bellman-Ford, dopo ogni operazione di aggiornamento.$G = (V,E)$$e$$E$$e$$E$

Modifica: sotto c'è una versione semplificata del problema:

Viene fornito un grafico ponderato , costituito da bordi unidirezionali e due vertici critici s e t . Viene inoltre fornito un set C di bordi bidirezionali candidati . Devo costruire un bordo ( u , v ) ∈ C per ridurre al minimo la distanza da s a t .$G(V,E)$$s$$t$$C$$(u,v) \in C$$s$$t$

Il problema, come probabilmente avrete notato, è un problema piuttosto difficile. Il controllo del Web porterà ad alcune istanze complesse che probabilmente non ti serviranno. Ecco una soluzione - come richiesto (cioè non è necessario ricalcolare tutto da zero).

nel caso di aggiungere un bordo , quindi utilizzando la matrice della distanza già costruita, procedere come segue:$(u,v)$

Per ogni coppia di nodi ed y di controllo se d ( ( x , u ) ) + c ( ( u , v ) ) + d ( ( v , y ) ) < d ( ( x , y ) ) - questo può essere fatto in O ( n 2 ) poiché stai confrontando ogni coppia di nodi.$x$$y$$d((x,u)) + c((u,v)) + d((v,y)) < d((x,y))$$O(n^2)$

Per il caso di eliminazione bordo: Data la matrice di distanza già costruito, allora si può avere per ogni nodo un albero più breve percorso radice in u . Se il bordo cancellato e non si trova in quell'albero, i percorsi più brevi da u all'altro non sono interessati - (rimangono gli stessi).$u$$u$$e$$u$

$e$$u$$v$$\pi(u,v)$$e$$u$$v$

se vuoi avere risultati migliori di così, dai un'occhiata a:

1. Demetrescu, Camil e Giuseppe F. Italiano. "Un nuovo approccio alla dinamica di tutte le coppie percorsi più brevi." Journal of the ACM (JACM) 51.6 (2004): 968-992. (può essere trovato liberamente da Google)

2. o dai un'occhiata a questo sondaggio ben scritto

Il problema che stai chiedendo è un noto problema algoritmico. In realtà è ancora aperto, quanto sia difficile questo problema. Inoltre dovresti sapere che ci sono diverse incarnazioni di questo problema. Al contrario di ciò che stai chiedendo, di solito vengono restituite solo le distanze, mentre stai chiedendo i percorsi più brevi effettivi. Si noti che questi percorsi possono essere già molto lunghi. Gli algoritmi dei grafici dinamici distinguono solo le eliminazioni dei bordi (algoritmi dg decrementali), solo gli inserimenti dei bordi (algoritmi dg incrementali) e gli inserimenti e le eliminazioni dei bordi (algoritmi dg completamente dinamici). Quindi sei interessato agli algoritmi incrementali .

$O(n^2(\log n +\log^2 (1+m/n))$$O(1)$$O(n\log n)$bordi, quindi potresti semplicemente ricalcolare da zero con Dijkstra e Fibonacci-heap e ottenere lo stesso tempo di esecuzione dell'algoritmo di Thorup. Quindi, se i tuoi grafici non sono densi, consiglierei di usare Dijkstra.

Non sono a conoscenza di alcun algoritmo incrementale migliore . Ma dovresti fare una ricerca web se ci sono risultati più recenti per questo problema specializzato.

Credo che l'algoritmo AD * potrebbe aiutarti.

http://www.cs.cmu.edu/~ggordon/likhachev-etal.anytime-dstar.pdf

Quando vengono ricevute informazioni aggiornate sul grafico sottostante, l'algoritmo ripara in modo incrementale la sua soluzione precedente. Il risultato è un approccio che combina i vantaggi di sempre e pianificatori incrementali per fornire soluzioni efficienti a problemi di ricerca complessi e dinamici

Punti salienti di AD *: è "sempre", il che significa che può darti una "soluzione subottimale" molto rapidamente, anche se potrebbe non essere la migliore. Dato abbastanza tempo, però, restituirà la soluzione ottimale. Inoltre, è possibile limitare la soluzione non ottimale in modo che non sia peggiore della soluzione ottimale mediante una costante definita dall'utente. Questo ti dà la possibilità di usarlo in uno scenario di pianificazione in tempo reale in cui avere una soluzione ok (dove "okay" è teoricamente limitato) è meglio che non avere alcuna soluzione.

http://www.cs.cmu.edu/~maxim/software.html