Efficiente campionamento più brevi

Lasciate $G$ un grafo, e lasciare $s$ e $t$ essere due vertici di $G$ . È possibile campionare in modo efficiente un percorso $s$ - più breve in $t$modo uniforme e indipendente in modo casuale dall'insieme di tutti i percorsi più brevi tra $s$ e $t$ ? Per semplicità, possiamo presumere che $G$ sia semplice, non orientato e non ponderato.

Anche in molti grafici ristrette il numero di cammini minimi tra $s$ e $t$ può essere esponenziale nella dimensione di $G$ . Pertanto, saremmo naturalmente, come evitare di realtà calcolando tutte le più breve $s$ - $t$ percorsi. Non conosco il caso generale, ma mi sembra che possiamo raggiungere questo obiettivo per alcune classi di grafi speciali.

Sembra qualcosa che qualcuno deve aver considerato prima. C'è qualche ricerca esistente in questo, o è in realtà semplice da fare anche per i grafici generali?

Non sono sicuro al 100% che questa risposta sia corretta, ma ecco qui:

Penso che puoi ridurlo a qualsiasi percorso uniformemente uniforme, da $s-t$ , in un DAG con una sola sorgente e un singolo sink.

Dato un grafico $G$

1. Crea un nuovo digrafo vuoto, .$H$
2. Primo: esegui la parte BFS del percorso più breve di Dijkstra, partendo da , segna tutti i nodi con la loro distanza più breve da-$s$ .$s$
3. Sia la distanza minima da s - v ; che conosciamo dal passaggio BFS dell'algoritmo del percorso più breve di Dijkstra.$d(s,v)$$s-v$
4. Quindi fai il passo successivo dell'algoritmo del percorso più breve di Dijkstra, ottieni il percorso più breve, memorizzalo in (andando indietro da t a $\mathbf p$$t$$s$ ).
5. Ora avvia il seguente ciclo; spiegazione nei commenti e sotto:
   • $q_0=\{t\}$
   • Mentre $q_0 \ne \emptyset$
     • $q_1= \emptyset$
     • Per $u \in q_0$
       • Quindi vogliamo trovare tutti i possibili nodi successivi per questo sottotraccia più breve da $t-u$
       • Per tutti i tale che d ( s , v ) < d ( s , u $\text{edge}(u,v) \in G$$d(s,v) < d(s,u)$
         • è un nodo vicino, con meno d ( s , ⋅ ) (sarà 1 in meno)$v$$d(s,\cdot)$$1$
         • Pertanto, è possibile sottotraccia in un percorso più breve.$t-u-v$
         • Inserisci $v \rightarrow H, \text{di-edge}(u,v)\rightarrow H$
         • Ora dobbiamo controllare i vicini di v minori il prossimo turno.$v$
         • Inserisci $v \rightarrow q_1$
     • Impostare su q $q_0$$q_1$ :
       • $q_0 \leftarrow q_1$

Essenzialmente, sto raccogliendo tutti i possibili nodi che possono essere utilizzati nel percorso più breve, e metterli in .$H$

Maggiori informazioni su come funziona:

L'algoritmo del percorso più breve di Dijkstra funziona eseguendo prima un BFS e contrassegnando tutti i nodi con i percorsi più brevi da s - v . Il prossimo passo è tornare indietro da t - s e seguire indietro i nodi meno vicini.$v\in G$$s-v$$t-s$

Il fatto è che qui puoi scegliere uno dei nodi meno vicini. Quello che faccio qui è raccogliere tutti i nodi meno vicini ogni passaggio, il che significa che conto per tutti i percorsi più brevi.

Ora pensi rapidamente, ma hey, perché li sta enumerando in modo esponenziale, ma la mia strada non lo è?

La risposta è che, poiché utilizzo un set per evitare di aggiungere due volte gli stessi nodi, evito di ricalcolarlo per ogni possibile percorso.

Ora abbiamo un DAG che possiamo attraversare in qualsiasi modo da , e ottenere un percorso inverso più breve da s - t . Il grafico dovrebbe avere t come unica fonte e s come unico sink.$t-s$$s-t$$t$$s$

Se quanto sopra è corretto, penso che possiamo fare un ulteriore passo avanti e risolvere il problema come segue.

Assegna a ciascun nodo nel DAG un peso-nodo; il peso del nodo sarà il numero di percorsi da quel nodo a . Chiamiamolo w ( v ) .$s$$w(v)$

È possibile calcolare questi rapidamente, vedere Algoritmo che trova il numero di semplici percorsi da s a t in G .

Una volta che abbiamo il peso del nodo, possiamo scegliere uniformemente un percorso per:

• Layout del DAG come struttura di livello (per visualizzazione)
• Ad ogni livello, scegliere un ordinamento arbitrario tra i nodi, ad es. una nozione di "da sinistra a destra".
• Attraversare il DAG: ad ogni passo , i ∈ [ 1 , | p | ] (dove | ⋅ $i$$i \in \left[1,\left|\mathbf p\right|\right]$$|\cdot|$ indica la dimensione di, in questo caso, la lunghezza del percorso più breve):
  • Let tramite il nodo corrente (a partire da $u_i$$t$ )
  • Sommate tutti i pesi dei figli di , e l'utilizzo di un RNG, scegliere uno nodo figlio, v $u_i$$v_i$ , in modo uniforme tra i bambini ponderati.
  • Imposta e vai al passaggio successivo$u_{i+1} = v_i$

Ecco una soluzione basata sulle idee nella risposta di Realz Slaw. Fondamentalmente è una riesposizione delle sue idee che potrebbe essere più chiara o più facile da seguire. Il piano è che procederemo in due fasi:

1. In primo luogo, si costruirà un grafico con la seguente struttura: qualsiasi percorso da s a t in S è un cammino minimo da s a t in G , ed ogni cammino minimo da s a t in G è presente anche in S . Pertanto, S contiene esattamente i percorsi più brevi in G : tutti i percorsi più brevi e niente di più. Come succede, S sarà un DAG.$S$$s$$t$$S$$s$$t$$G$$s$$t$$G$$S$$S$$G$$S$

2. Successivamente, si campionare uniformemente a caso da tutti i percorsi da a t in S .$s$$t$$S$

Questo approccio si generalizza a un grafico diretto arbitrario , purché tutti i bordi abbiano un peso positivo, quindi spiegherò il mio algoritmo in questi termini. Lascia che w ( u , v ) indichi il peso sul bordo u → v . (Questo generalizza l'affermazione del problema che hai dato. Se hai un grafico non ponderato, supponi solo che ogni bordo abbia peso 1. Se hai un grafico non orientato, tratta ogni bordo non orientato ( u , v ) come i due bordi diretti u → v e v → u .)$G$$w(u,v)$$u \to v$$(u,v)$$u\to v$$v\to u$

Fase 1: estratto di . $S$ Esegui un algoritmo di percorsi più brevi a sorgente singola (ad esempio, l'algoritmo di Dijkstra) su , a partire dalla sorgente s . Per ogni vertice v in G , d ( s , v ) denota la distanza da s a v .$G$$s$$v$$G$$d(s,v)$$s$$v$

Ora definisci il grafico come segue. È costituito da ogni bordo u → v tale che (1) u → v sia un bordo in G e (2) d ( s , v ) = d ( s , u ) + w ( u , v ) .$S$$u \to v$$u \to v$$G$$d(s,v) = d(s,u) + w(u,v)$

Il grafico ha alcune proprietà convenienti:$S$

• Ogni percorso più breve da a t in G esiste come percorso in S : un percorso più breve s = v 0 , v 1 , v 2 , … , v k = t in G ha la proprietà che d ( s , v i + 1 ) = d ( s , v i ) + w ( v i , v $s$$t$$G$$S$$s=v_0,v_1,v_2,\dots,v_k=t$$G$$d(s,v_{i+1})=d(s,v_i)+w(v_i,v_{i+1})$, so the edge $v_i \to v_{i+1}$ is present in $S$.

• Every path in $S$ from $s$ to $t$ is a shortest path in $G$. In particular, consider any path in $S$ from $s$ to $t$, say $s=v_0,v_1,v_2,\dots,v_k=t$. Its length is given by the sum of the weights of its edges, namely $\sum_{i=1}^k w(v_{i-1},v_i)$$S$$\sum_{i=1}^k (d(s,v_i)-d(s,v_{i-1})$$d(s,t)-d(s,s)=d(s,t)$. Therefore, this path is a shortest path from $s$ to $t$ in $G$.

• Finally, the absence of zero-weight edges in $G$ implies that $S$ is a dag.

Step 2: sample a random path. Now we can throw away the weights on the edges in $S$, and sample a random path from $s$ to $t$ in $S$.

To help with this, we will do a precomputation to compute $n(v)$ for each vertex $v$ in $S$, where $n(v)$ counts the number of distinct paths from $v$ to $t$. This precomputation can be done in linear time by scanning the vertices of $S$ in topologically sorted order, using the following recurrence relation:

where $\text{succ}(v)$ denotes the successors of $v$, i.e., $\text{succ}(v) = \{w : v \to w \text{ is an edge in $S$}\}$, and where we have the base case $n(t)=1$.

Next, we use the $n(\cdot)$ annotation to sample a random path. We first visit node $s$. Then, we randomly choose one of the successors of $s$, with successor $w$ weighted by $n(w)$. In other words:

choosesuccessor(v):
    n = 0
    for each w in succ(w):
        n = n + n(w)
    r = a random integer between 0 and n-1
    n = 0
    for each w in succ(w):
        n = n + n(w)
        if r < n:
            return w

To choose a random path, we repeatedly iterate this process: i.e., $v_0=s$, and $v_{i+1} =$ choosesuccessor$(v_i)$. The resulting path is the desired path, and it will be sampled uniformly at random from all shortest paths from $s$ to $t$.

Hopefully this helps you understand Realz Slaw's solution more easily. All credit to Realz Slaw for the beautiful and clean solution to this problem!

The one case this doesn't handle is the case where some edges have weight 0 or negative weight. However, the problem is potentially not well-defined in that case, as you can have infinitely many shortest paths.