Amostragem eficiente dos caminhos - uniformes e independentes, aleatoriamente

Deixe ser um gráfico, e deixá- e seja dois vértices de . Podemos amostrar eficientemente um caminho - mais curto de maneira uniforme e independente, aleatoriamente, a partir do conjunto de todos os caminhos mais curtos entre e ? Por simplicidade, podemos assumir que é simples, sem direção e sem ponderação.s t G s t s t $G$$s$$t$$G$$s$$t$$s$$t$$G$

Mesmo em muitos gráficos limitados, o número de caminhos mais curtos entre e podem ser exponencial do tamanho de . Portanto, gostaríamos naturalmente de evitar calcular todos os caminhos - curtos. Não conheço o caso geral, mas parece-me que podemos conseguir isso para algumas classes gráficas especiais.t G s $s$$t$$G$$s$$t$

Parece algo que alguém deve ter considerado antes. Existe alguma pesquisa existente sobre isso, ou é de fato simples, mesmo para gráficos gerais?

Não tenho 100% de certeza de que esta resposta esteja correta, mas aqui vai:

Eu acho que você pode reduzir isso para qualquer caminho uniformemente aleatório, de , em um DAG com uma única fonte e um único coletor.$s-t$

Dado um gráfico$G$

1. Fazer uma nova d�rafo vazio, .$H$
2. Primeiro: executar a parte BFS de menor caminho de Dijkstra, a partir de , marcar todos os nós com seus curtos-distância de- .$s$$s$
3. Seja a distância mínima de ; que sabemos da etapa BFS do algoritmo de caminho mais curto de Dijkstra.s - $d(s,v)$$s-v$
4. Em seguida, execute o próximo passo do algoritmo de caminho mais curto de Dijkstra, obtenha o caminho mais curto, armazene-o em (retornando de para ). t $\mathbf p$$t$$s$
5. Agora inicie o seguinte loop; expansão nos comentários e abaixo:
   • $q_0=\{t\}$
   • Enquanto$q_0 \ne \emptyset$
     • $q_1= \emptyset$
     • Para$u \in q_0$
       • Então, queremos encontrar todos os próximos nós possíveis para esse subcaminho mais curto de$t-u$
       • Para todos os modo qued ( s , v ) < d ( s , u $\text{edge}(u,v) \in G$$d(s,v) < d(s,u)$
         • d ( s , ⋅ ) $v$ é um nó vizinho, com menos (será menos)$d(s,\cdot)$$1$
         • Portanto, é possível subcaminho no caminho mais curto.$t-u-v$
         • Coloque$v \rightarrow H, \text{di-edge}(u,v)\rightarrow H$
         • Agora precisamos verificar os vizinhos menores de no próximo turno.$v$
         • Coloque$v \rightarrow q_1$
     • Defina como : q $q_0$$q_1$
       • $q_0 \leftarrow q_1$

Essencialmente, estou recolher todos os nós possíveis que podem ser usados no caminho mais curto, e colocando-os em .$H$

Mais sobre como isso funciona:

O algoritmo de caminho mais curto de Dijkstra funciona primeiro executando um BFS e marcando todos os nós com seus caminhos mais curtos de . O próximo passo é voltar de e seguir os nós menos vizinhos.s - v t - $v\in G$$s-v$$t-s$

A questão é: aqui você pode escolher qualquer um dos nós menos vizinhos. O que faço aqui é coletar todos os nós menos vizinhos a cada etapa, o que significa que sou responsável por todos os caminhos mais curtos.

Agora você pensa rapidamente, mas ei, por que enumerá-los exponencialmente, mas meu caminho não é?

A resposta é: porque eu uso um conjunto para evitar adicionar os mesmos nós duas vezes, evito recalcular isso para cada caminho possível.

Agora temos um DAG que podemos percorrer de qualquer forma a partir de e obter um caminho mais curto e invertido de . O gráfico deve ter como a única fonte como o único coletor.s - t t $t-s$$s-t$$t$$s$

Se o exposto acima estiver correto, acho que podemos dar um passo adiante e resolver o problema da seguinte maneira.

Atribua a cada nó no DAG um peso de nó; o peso do nó será o número de caminhos desse nó para . Vamos chamar isso de .w ( v $s$$w(v)$

Você pode calcular estes rapidamente, ver algoritmo que encontra o número de caminhos simples de s para t em G .

Depois de termos o peso do nó, podemos escolher um caminho uniformemente:

• Layout do DAG como uma estrutura de nível (para visualização)
• Em cada nível, escolha uma ordem arbitrária entre os nós, ie. uma noção de "esquerda para a direita".
• Percorrendo o DAG: em cada etapa , (onde significa tamanho do, nesse caso, o comprimento do menor -caminho): i ∈ [ 1 , | p | ] | ⋅ $i$$i \in \left[1,\left|\mathbf p\right|\right]$$|\cdot|$
  • Seja o nó atual (começando em )$u_i$$t$
  • Adicione todos os pesos dos filhos de e, usando um RNG, escolha um nó filho, , uniformemente entre os filhos com peso.v $u_i$$v_i$
  • Defina e vá para a próxima etapa$u_{i+1} = v_i$

Aqui está uma solução baseada nas idéias da resposta de Realz Slaw. É basicamente uma reexposição de suas idéias que pode ser mais clara ou mais fácil de seguir. O plano é que prosseguiremos em duas etapas:

1. Em primeiro lugar, vamos construir um gráfico com a seguinte propriedade: qualquer caminho de a em é um caminho mais curto de a em , e cada caminho mais curto de a em também está presente em . Assim, contém exatamente os caminhos mais curtos em : todos os caminhos mais curtos e nada mais. Por acaso, será um DAG.s t S s t L s T L S S G $S$$s$$t$$S$$s$$t$$G$$s$$t$$G$$S$$S$$G$$S$

2. Em seguida, vamos amostra uniformemente aleatoriamente a partir de todos os caminhos de a em .t $s$$t$$S$

Essa abordagem generaliza para um gráfico direcionado arbitrário , desde que todas as arestas tenham peso positivo, então vou explicar meu algoritmo nesses termos. Seja o peso na borda . (Este generaliza a declaração do problema que você deu. Se você tem um gráfico não ponderado, simplesmente assumir cada aresta tem peso 1. Se você tiver um grafo não direcionado, tratar cada aresta sem direção como as duas arestas dirigidas e )w ( u , v ) u → v ( u , v ) u → v v → $G$$w(u,v)$$u \to v$$(u,v)$$u\to v$$v\to u$

Passo 1: extracto de . $S$ Execute um algoritmo de caminhos mais curtos de fonte única (por exemplo, algoritmo de Dijkstra) em , iniciando na fonte . Para cada vértice em , deixe denotar a distância de a .s v G d ( s , v ) s $G$$s$$v$$G$$d(s,v)$$s$$v$

Agora defina o gráfico seguinte maneira. Consiste em toda aresta modo que (1) seja uma aresta em G e (2) d ( s , v ) = d ( s , u ) + w ( u , v ) .u → v u → $S$$u \to v$$u \to v$$G$$d(s,v) = d(s,u) + w(u,v)$

O gráfico possui algumas propriedades convenientes:$S$

• Todo caminho mais curto de a em existe como um caminho em : um caminho mais curto em tem a propriedade de que , assim que a borda está presente em .t G S s = v 0 , v 1 , v 2 , … , v k = t G d ( s , v i + 1 ) = d ( s , v i ) + w ( v i , v i + 1 ) v i → v i + 1$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})$$v_i \to v_{i+1}$$S$

• Cada caminho em a partir de a é um caminho mais curto em . Em particular, considere qualquer caminho em de a , diga . Seu comprimento é dado pela soma dos pesos de suas arestas, ou seja, , mas pela definição de , essa soma é , que é telescópico para . este caminho é um caminho mais curto de a em .s t G S s t s = v 0 , v 1 , v 2 , … , v k = t ∑ k i = 1 w ( v i - 1 , v i ) S ∑ k i = 1 ( d ( s , v i ) - d ( s , v i $S$$s$$t$$G$$S$$s$$t$$s=v_0,v_1,v_2,\dots,v_k=t$$\sum_{i=1}^k w(v_{i-1},v_i)$$S$d(s,t)-d(s,s)=d(s,t)st$\sum_{i=1}^k (d(s,v_i)-d(s,v_{i-1})$$d(s,t)-d(s,s)=d(s,t)$$s$$t$$G$

• Finalmente, a ausência de arestas de peso zero em implica que é um dag.$G$$S$

Etapa 2: experimente um caminho aleatório. Agora podemos jogar fora os pesos nas bordas em , e provar um caminho aleatório de para em .s t $S$$s$$t$$S$

Para ajudar, faremos uma pré-computação para calcular para cada vértice em , em que conta o número de caminhos distintos de a . Essa pré-computação pode ser feita em tempo linear, varrendo os vértices de na ordem classificada topologicamente, usando a seguinte relação de recorrência:v S n ( v ) v t $n(v)$$v$$S$$n(v)$$v$$t$$S$

onde indica os sucessores de , ou seja, e onde temos o caso base .v succ ( v ) = { w : v → w  é uma aresta em  S } n ( t ) = $\text{succ}(v)$$v$$\text{succ}(v) = \{w : v \to w \text{ is an edge in $S$}\}$$n(t)=1$

Em seguida, usamos a anotação para provar um caminho aleatório. Primeiro visitamos o nó . Em seguida, escolhemos aleatoriamente um dos sucessores de , com o sucessor ponderado por . Em outras palavras:s s w n ( w $n(\cdot)$$s$$s$$w$$n(w)$

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

Para escolher um caminho aleatório, repetimos repetidamente este processo: ou seja, e v i + 1 = ( v i ) . O caminho resultante é o caminho desejado e será amostrado uniformemente aleatoriamente em todos os caminhos mais curtos, de s a t .$v_0=s$$v_{i+1} =$ choosesuccessor$(v_i)$$s$$t$

Espero que isso ajude você a entender a solução de Realz Slaw mais facilmente. Todo o crédito a Realz Slaw pela solução bonita e limpa para esse problema!

O único caso que não trata é o caso em que algumas arestas têm peso 0 ou peso negativo. No entanto, o problema potencialmente não está bem definido nesse caso, pois você pode ter infinitamente muitos caminhos mais curtos.