Algoritmo que encontra o número de caminhos simples de a em

Alguém pode sugerir-me um algoritmo de tempo linear, que recebe como entrada um dirigido acíclico gráfico e dois vértices e e devolve o número de caminhos simples de a em . Eu tenho um algoritmo no qual executarei um DFS (Depth First Search), mas se o DFS encontrar , ele não mudará a cor (de branco para cinza) de qualquer um dos nós que no caminho para que se esse for o subcaminho de qualquer outro caminho, o DFS também o percorrerá novamente. Por exemplo, considere a lista de adjacências em que precisamos encontrar o número de caminhos de p a v .$G=(V,E)$$s$$t$$s$$t$$G$
$t$$s \rightsquigarrow t$$p$$v$

$$\begin{array}{|c|c c c|} \hline p &o &s &z \\ \hline o &r &s &v\\ \hline s &r \\ \hline r &y \\ \hline y &v \\ \hline v &w \\ \hline z & \\ \hline w &z \\ \hline \end{array}$$ Aqui o DFS começará com $p$ e digamos que vá para $p \rightsquigarrow z$ uma vez que não encontra $v$ DFS será executado normalmente. caminho é $psryv$ pois encontrar $v$ que não irá alterar a cor dos vértices $s,r,y,v$ para grey.Then o caminho $pov$ desde cor de $v$ é ainda white.Then o caminho $posryv$ desde cor de $s$ é branco e de forma semelhante caminho $poryv$.Também é mantido um contador que é incrementado quando $v$ é encontrado.

Meu algoritmo está correto? caso contrário, quais modificações são necessárias para torná-lo correto ou quaisquer outras abordagens serão muito apreciadas.

Nota : Aqui eu considerei o algoritmo DFS que é fornecido no livro "Introdução aos algoritmos por Cormen", no qual ele colore os nós de acordo com seu status. Portanto, se o nó não for visitado, inexplorado e explorado, a cor será branca cinza e preto, respectivamente. Todas as outras coisas são padrão.

Sua implementação atual calculará o número correto de caminhos em um DAG. No entanto, ao não marcar caminhos, levará um tempo exponencial. Por exemplo, na ilustração abaixo, cada estágio do DAG aumenta o número total de caminhos em um múltiplo de 3. Esse crescimento exponencial pode ser tratado com programação dinâmica.

A computação do número de caminhos - em um DAG é dada pela recorrência, t Caminhos ( u ) = { 1 se  u = t ∑ ( u , v ) ∈ E Caminhos ( v ) $s$$t$

$$\text{Paths}(u) = \begin{cases} 1 & \text{if } u = t \\ \sum_{(u,v) \in E} \text{Paths}(v) & \text{otherwise.}\\ \end{cases}$$

Uma simples modificação do DFS calculará isso como

def dfs(u, t):
    if u == t:
        return 1
    else:
        if not u.npaths:
            # assume sum returns 0 if u has no children
            u.npaths = sum(dfs(c, t) for c in u.children)
        return u.npaths

Não é difícil ver que cada aresta é vista apenas uma vez, portanto, um tempo de execução de .$O(V + E)$

Você só precisa observar que o número de caminhos de um nó para o nó de destino é a soma do número de caminhos de seus filhos para o destino. Você sabe que esse algoritmo sempre para porque seu gráfico não possui ciclos.

Agora, se você salvar o número de caminhos de um nó no destino ao visitar os nós, a complexidade do tempo se tornará linear no número de vértices e a memória linear no número de nós.

O número de caminhos entre dois vértices em um DAG pode ser encontrado usando a representação da matriz de adjacência.

Suponha que A é a matriz de adjacência de G. Tomando o poder K de A depois de adicionar a matriz de identidade, fornece o número de caminhos de comprimento <= K.

Como o comprimento máximo de qualquer caminho simples em um DAG é | V | -1, o cálculo de | V | -1ª potência forneceria o número de caminhos entre todos os pares de vértices.

O cálculo da | V | -1ª potência pode ser feito executando multiplicações de log (| V | -1) cada um dos TC: | V | ^ 2.