Алгоритм, который находит число простых путей от

Можно ли предложить мне алгоритм линейного времени , который принимает в качестве входных данных ориентированного ациклического граф и две вершины S и T и возвращает число простых путей от й до т в G . У меня есть алгоритм, в котором я буду запускать DFS (Поиск в глубину), но если DFS найдет t, то он не изменит цвет (с белого на серый) ни одного из узлов, которые входят в путь s ⇝ $G=(V,E)$$s$$t$$s$$t$$G$
$t$$s \rightsquigarrow t$ так, что, если это подпуть любого другого пути, то и DFS снова проходит этот подпуть. Например, рассмотрим список смежности, где нам нужно найти количество путей от до v . P O S Z $p$$v$
Здесь DFS будет начинаться сp,а затем предположим, что он переходит кp⇝z,поскольку он не сталкивается сvDFS будет работать нормально.Теперьвторой путь - этоpsryv,поскольку он сталкивается сv,мы не будем менять цвет вершинs,r,y,vк серому. Тогда путьpov,так как цветvвсе еще белый. Затем путьposryv,так как цвет

$$\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}$$ $p$$p \rightsquigarrow z$$v$$psryv$$v$$s,r,y,v$$pov$$v$$posryv$$s$ is white and similarly of path $poryv$.Also a counter is maintained which get incremented when $v$ is encountered.

Is my algorithm correct? if not, what modifications are needed to make it correct or any other approaches will be greatly appreciated.

Note:Here I have considered the DFS algorithm which is given in the book "Introduction to algorithms by Cormen" in which it colors the nodes according to its status.So if the node is unvisited , unexplored and explored then the color will be white,grey and black respectively.All other things are standard.

Your current implementation will compute the correct number of paths in a DAG. However, by not marking paths it will take exponential time. For example, in the illustration below, each stage of the DAG increases the total number of paths by a multiple of 3. This exponential growth can be handled with dynamic programming.

Computing the number of $s$-$t$ paths in a DAG is given by the recurrence,

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

A simple modification of DFS will compute this given as

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

It is not difficult to see that each edge is looked at only once, hence a runtime of $O(V + E)$.

You only need to notice that the number of paths from one node to the target node is the sum of the number of paths from its children to the target. You know that this algorithm will always stop because your graph doesn't have any cycles.

Now, if you save the number of paths from one node to the target as you visit the nodes, the time complexity becomes linear in the number of vertices and memory linear in the number of nodes.

The number of paths between any two vertices in a DAG can be found using adjacency matrix representation.

Suppose A is the adjacency matrix of G. Taking Kth power of A after adding identity matrix to it, gives the number of paths of length <=K.

Since the max length of any simple path in a DAG is |V|-1, calculating |V|-1 th power would give number of paths between all pairs of vertices.

Calculating |V|-1 th power can be done by doing log(|V|-1) muliplications each of TC: |V|^2.