Algorithmus, der die Anzahl der einfachen Pfade von

$G=(V,E)$$s$$t$$s$$t$$G$
$t$p V p o s z o r s V s r r y y v v w $s \rightsquigarrow t$Wenn dies der Unterpfad eines anderen Pfads ist, durchläuft auch DFS diesen Unterpfad erneut. Betrachten Sie beispielsweise die Adjazenzliste, in der die Anzahl der Pfade von nach . Hier beginnt DFS mit und geht dann beispielsweise zu da es nicht auf stößt. DFS wird normal ausgeführt path ist da es auf trifft. Wir werden die Farbe der Eckpunkte in grau ändern .$p$$v$
pp⇝zvpsryvvs,r,y,vpovvposryvsporyv

$$\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$ da die Farbe von immer noch weiß ist. Dann ist der Pfad da die Farbe von weiß ist und ähnlich wie der Pfad Außerdem wird ein Zähler verwaltet, der inkrementiert wird, wenn angetroffen wird.$v$$posryv$$s$$poryv$$v$

Ist mein Algorithmus korrekt? Wenn nicht, werden die Änderungen, die erforderlich sind, um es zu korrigieren, oder andere Ansätze sehr geschätzt.

Hinweis : Hier habe ich den DFS-Algorithmus in dem Buch "Einführung in die Algorithmen von Cormen" betrachtet, in dem die Knoten gemäß ihrem Status gefärbt werden. Wenn der Knoten nicht besucht, nicht erkundet und erkundet wird, ist die Farbe weiß. grau und schwarz. Alle anderen Dinge sind Standard.

Ihre aktuelle Implementierung berechnet die richtige Anzahl von Pfaden in einer DAG. Wenn Sie jedoch keine Pfade markieren, dauert dies exponentiell lange. In der folgenden Abbildung erhöht beispielsweise jede Stufe der DAG die Gesamtzahl der Pfade um ein Vielfaches von 3. Dieses exponentielle Wachstum kann mit dynamischer Programmierung bewältigt werden.

Die Berechnung der Anzahl der - - Pfade in einer DAG ergibt sich aus der Wiederholung: t Pfade ( u ) = { 1, wenn  u = t ∑ ( u , v ) ∈ E Pfade ( 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}$$

Eine einfache Modifikation von DFS berechnet dies als

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

Es ist nicht schwer zu erkennen, dass jede Kante nur einmal betrachtet wird, daher eine Laufzeit von .$O(V + E)$

Sie müssen nur beachten, dass die Anzahl der Pfade von einem Knoten zum Zielknoten die Summe der Anzahl der Pfade von den untergeordneten Knoten zum Ziel ist. Sie wissen, dass dieser Algorithmus immer anhält, da Ihr Diagramm keine Zyklen aufweist.

Wenn Sie jetzt die Anzahl der Pfade von einem Knoten zum Ziel speichern, während Sie die Knoten besuchen, wird die Zeitkomplexität linear in der Anzahl der Scheitelpunkte und der Speicher linear in der Anzahl der Knoten.

Die Anzahl der Pfade zwischen zwei beliebigen Eckpunkten in einer DAG kann unter Verwendung der Adjazenzmatrixdarstellung ermittelt werden.

Angenommen, A ist die Adjazenzmatrix von G. Wenn man die K-te Potenz von A nach der Addition der Identitätsmatrix nimmt, erhält man die Anzahl der Pfade mit einer Länge <= K.

Da die maximale Länge eines einfachen Pfades in einer DAG | V | -1 ist, würde die Berechnung der | V | -1-ten Potenz die Anzahl der Pfade zwischen allen Knotenpaaren ergeben.

Die Berechnung der | V | -1-ten Potenz kann durchgeführt werden, indem log (| V | -1) -Multiplikationen von TC: | V | ^ 2 durchgeführt werden.