Sottografo contenente tutti i nodi e gli spigoli che fanno parte di percorsi st semplici limitati in lunghezza in un grafico non orientato

Abbastanza simile alla mia domanda precedentemente pubblicata . Questa volta, tuttavia, il grafico non viene indirizzato.

Dato

Un grafico non orientato senza bordi multipli o anelli, $G$
Un vertice sorgente , $s$
Un vertice bersaglio , $t$
Lunghezza massima del percorso , $l$

Sto cercando - Un sottografo di che contiene qualsiasi vertice e qualsiasi bordo in (e solo quelli), che fanno parte di almeno un percorso semplice da a con lunghezza . $G'$ $G$ $G$ $s$ $t$ $\leq l$

Appunti:

Non ho bisogno di enumerare i percorsi.
Sto cercando un algoritmo efficiente (sia tempo che memoria), poiché ho bisogno di eseguirlo su grafici molto grandi (10 ^ 8 vertici, 10 ^ 9 spigoli).

ds.algorithms graph-algorithms shortest-path

— Lior Kogan
fonte

controllalo. Ho trovato questo documento, che sembra fare una simile riduzione del flusso di costo minimo, ma utilizza le caratteristiche speciali della rete per risolverlo più velocemente degli algoritmi MCF generali.

— RB

Risposte:

Bene, il problema è in dopo tutto. Manterrò la risposta precedente poiché funziona anche per il caso diretto (che è NPC, come risposta sull'altra domanda), e mostra che è rispetto a . $P$ $FPT$ $l$

Nel caso non indirizzato, è risolvibile, in modo deterministico tramite il flusso di costo minimo (ciò potrebbe non funzionare sulle scale a cui si fa riferimento nella domanda, ma è meglio dell'algoritmo esponenziale.

La seguente procedura deciderà se parte del bordo deve far parte del grafico di output. Per rispondere al problema originale basta passare su tutti i bordi. $e=(u,v)\in E$

Per creare la rete di flusso, procedere come segue:

Passaggio 1: espandi per avere un vertice sostituisci con i bordi (sono diretti come parte della rete di flusso), impostare il loro costo su 0. $e$ $x_e$ $e$ $(u,x_e),$ $(x_e,u),(v,x_e),(x_e,v)$

Fase 2: sostituire ogni vertice , fatta eccezione per da due vertici e , e aggiungere un bordo . Imposta il costo di questi bordi su 1. $t$ $x_e$ $t^-$ $t^+$ $(t^-,t^+)$

Passaggio 3: sostituire ogni bordo con i bordi . Impostare il costo di questi bordi su 0. $\{a,b\}\in E$ $(a^+,b^-),(b^+,a^-)$

Passaggio 4: aggiungere un nuovo vertice aggiungere i bordi con costo 0. $y_e$ $(s,y_e),(t,y_e)$

Passaggio 5: impostare tutte le capacità su 1.

Ora eseguire l'algoritmo di flusso min costo, alla ricerca di un flusso di valore di 2 da al . $x_e$ $y_e$

Analisi:

$x_e$ $y_e$ $x_e\leadsto s\to y_e$ $x_e\leadsto t\to y_e$
I percorsi sono disgiunti, poiché per ogni vertice esiste solo 1 capacità nell'arco . $t$ $(t^-,t^+)$
I percorsi restituiti sono i due percorsi la cui somma delle distanze è minima e questo è anche il costo del flusso trovato. Questo ci consente di aggiungere al grafico di output o di eliminare in altro modo. $e$

— RB
fonte

È più facile comprendere l'argomento nella risposta sopra eliminando la riduzione al flusso diretto. C'è un cammino semplice da a contenente un nodo sse esiste un percorso da a e un percorso da a tale che e sono disgiunti nodo se non a . Questo utilizza in modo cruciale il non indiretto. Questo può essere verificato tramite flusso e la versione di costo può essere eseguita anche tramite flusso di costo minimo. Si può verificare se esiste un percorso semplice da a contenente

s

$s$

t

$t$

v

$v$

P

$P$

v

$v$

s

$s$

Q

$Q$

v

$v$

t

$t$

P

$P$

Q

$Q$

v

$v$

s

$s$

t

$t$

e

$e$ introducendo un nodo nel mezzo di .

e

$e$

— Chandra Chekuri,

@ChandraChekuri - è corretto, ma tieni presente che se il problema non ha il limite di lunghezza, c'è un algoritmo molto più semplice per decidere - vedi qui

— RB

Certo, sono consapevole anche di quella soluzione - concettualmente è bene capire i componenti biconnessi tramite percorsi disgiunti anche se si possono trovare vertici di taglio e componenti biconnessi direttamente tramite DFS.

— Chandra Chekuri,

@RB: grazie. L'algorihm suggerito può essere efficace quando l è relativamente grande, ma è probabilmente non ottimale per valori relativamente piccoli di l. Immagino di poter tagliare G prima rimuovendo qualsiasi vertice più lontano del pavimento (l / 2) da seil ceil (l / 2) da t.

— Lior Kogan,

Prova ad adattare l'algoritmo del percorso più breve successivo (chiamato anche algoritmo di Surballe per il caso di 2 percorsi che qui è interessante). Volete trovare 2 percorsi più brevi da (è meglio chiamarlo invece di poiché è lo stesso per tutti i bordi) per ogni . Penso che questo sia fattibile in modo efficiente prima calcolando un albero di percorso più breve da e quindi implementando il calcolo del secondo percorso con una certa attenzione.

y

$y$

y

$y$

y_{e}

$y_e$

x_{e}

$x_e$

y

$y$

— Chandra Chekuri,

Ecco una risposta sbagliata : genera alcuni vertici che fanno parte di percorsi non semplici da a e che non fanno parte di alcun percorso semplice da a di lunghezza . La risposta potrebbe essere ancora rilevante per l'applicazione del richiedente, quindi la lascio qui. $s$ $t$ $s$ $t$ $\le \ell$

Ecco un algoritmo che gira nel tempo (e in realtà è più veloce di questo quando è piccolo). $O(|V|+|E|)$ $\ell$

L'algoritmo esegue una ricerca BFS da che termina in profondità . Questo BFS fornisce un insieme di tutti i vertici raggiungibili da con un percorso di lunghezza al massimo , e calcola anche le distanze per ogni . Quindi farei lo stesso da e l'insieme e le distanze da . Infine, i vertici che stai cercando sono esattamente . I bordi sono esattamente quelli in ( $s$ $\ell$ $V_s$ $s$ $\ell$ $dist(s,v)$ $v \in V_s$ $t$ $V_t$ $t$ $V_{solution}=\{ v : v \in V_s \cap V_t, dist(s,v)+dist(t,v) \le \ell \}$ $E[V_{solution}]$ $=(v,u) \in E : u,v \in V_{solution}$ ).

Il tempo di esecuzione di questo algoritmo è sicuramente perché esegue solo due BFS. Ma il tempo di esecuzione è in realtà che sarà molto più piccolo della dimensione del grafico quando i quartieri -radius di e sono piccoli. $O(|V|+|E|)$ $O(|V_s| + |V_t| + |E[V_s]|+|E[V_t]|)$ $\ell$ $s$ $t$

Edit: probabilmente c'è un algoritmo po 'più veloce, in pratica, che fa un BFS da e della profondità soltanto piuttosto che . Questo scopre tutti i percorsi e quindi con un po 'di contabilità puoi trovare tutti i vertici. Questo riduce il tempo di esecuzione di una radice quadrata per il caso di un grande grafico dall'aspetto casuale quando è piccolo. $s$ $t$ $\ell/2$ $\ell$ $\ell$

— gnocco di mobius
fonte

Questo non obbliga il percorso ad essere semplice. Considera il semplice percorso grafico e . Restituirai come parte dell'output, anche se non esiste un semplice percorso st che attraversa ...

t - u - s - v - x

$t-u-s-v-x$

l = 4

$l=4$

v

$v$

v

$v$

— RB

Grazie per la correzione @RB. Ho modificato la mia risposta per notare che è sbagliato.

— gnocco di mobius

Questo è inteso come commento, ma è troppo lungo per essere pubblicato come commento.

Potresti anche essere interessato a chiavi grafiche o emulatori per i tuoi scopi. Una chiave di un grafico è un sottografo con pochi spigoli, ma distanze approssimativamente conservate. Un emulatore è un grafico cui bordi possono essere ponderati. $G = (V, E)$ $H = (V, E')$ $H = (V, E', w)$

Il miglior risultato per le chiavi è e un errore additivo di +6 sulle stime della distanza nel grafico. Il risultato migliore per gli emulatori è i bordi e un errore aggiuntivo di +4. Non è noto nemmeno se si può battere , anche se si può consentire che l'errore sia pollogaritmico. $O(n^{4/3})$ $O(n^{4/3})$ $O(n^{4/3})$

Se questo sembra utile, posso provare a scavare le costruzioni pertinenti per te.

— GMB
fonte