Route Existenz zwischen n Knotenpaaren

Wie kann man bei einem gerichteten azyklischen Graphen mit Knoten bestimmen, ob es einen Pfad zwischen einem der folgenden n Knotenpaare gibt ? Es gibt einen einfachen Algorithmus in (wobei m die Anzahl der Kanten ist), indem von jedem Knoten gesucht wird , aber kann es besser gemacht werden? $2n$ $(1 \rightarrow n+1), \ldots, (n \rightarrow n+n)$ $O(n \cdot (n + m))$ $1 \ldots n$

EDIT: Ich suche Existenz, nicht vollständige Pfade.

ds.algorithms graph-algorithms directed-acyclic-graph

— Alexandru
quelle

Es ist nicht ganz klar, was Sie fragen. Suchen Sie einen einzelnen Pfad mit den von Ihnen genannten Kanten? Oder suchen Sie mehrere Wege?

— Dave Clarke

@ Dave: Er sucht nach dem OP eines kleinen Stücks der transitiven Verschlussmatrix.

— Radu GRIGore

@Alexandru, 1-> 4, 2-> 3. Sie addieren 3-> 1, 4-> 2.

— Radu GRIGore

Sie können den transitiven Abschluss über eine schnelle Matrixmultiplikation berechnen, die besser wäre als die O (nm) -Zeit, wenn m groß ist.

— Chandra Chekuri

@alexandru: Das ist aber nicht das, was deine Frage gestellt hat, um fair zu sein. Sie haben nach einer schnelleren, nicht praktischen Implementierung gefragt (was eine gültige, aber separate Frage ist)

— Suresh Venkat

Antworten:

Wie Chandra Chekuri in einem Kommentar betonte, könnten Sie den transitiven Abschluss einfach durch schnelle Matrixmultiplikation berechnen und das Problem in O ( ) (verwenden Sie Ihre Lieblingsmethode, O ( ) über Coppersmith und Winograd oder praktischer mit Straßens O ( )), und dies wäre gut für dichte Graphen. $n^\omega$ $n^{2.376}$ $n^{2.81}$

Nun behaupte ich, wenn Sie diese Laufzeit für Ihr Problem für dichte Graphen übertreffen könnten, würden Sie einen Algorithmus für die Dreieckserkennung erhalten, der effizienter ist als die Berechnung des Produkts zweier Boolescher Matrizen. Die Existenz eines solchen Algorithmus ist ein großes offenes Problem.

Ich werde das Dreiecksproblem auf das Problem der Erreichbarkeit von n-Paaren-DAG reduzieren. Angenommen, wir erhalten einen Graphen G auf n Knoten und möchten bestimmen, ob G ein Dreieck enthält.

Erstellen Sie nun aus G eine DAG G 'wie folgt. Erstellen Sie vier Kopien der Scheitelpunktmenge , , , . für Kopien , für eine Kante wenn $V_1$ $V_2$ $V_3$ $V_4$ $u_i\in V_i$ $v_{i+1}\in V_{i+1}$ $i=1,2,3$ $(u_i,v_{i+1})$ $(u,v)$ war in G. Wenn wir nun fragen, ob es einen Pfad zwischen einem der Paare für alle G gibt, dann würde dies genau fragen, ob es in ein Dreieck gibt . Der aktuelle Graph hat Knoten und wir fragen nach Paaren. Wir können jedoch isolierte Dummy-Knoten hinzufügen und stattdessen Abfragen haben (indem wir eine Abfrage für verschiedene Paare hinzufügen wobei $(u_1, u_4)$ $u\in$ $G$ $4n$ $n$ $2n$ $3n$ $2n$ $(y,d)$ und ein Dummy), wodurch eine Knoten-Instanz genau Ihres Problems erhalten wird. $y\in V_2\cup V_3$ $d$ $6n$

— Jungfrau
quelle

Die topologische Sortierung ( ) arbeitet dann daran, ein Bit-Set von Knoten zu verbreiten, von denen aus jeder Knoten erreicht werden kann ( ). $O(m+n)$ $O(m n)$

Nach der topologische Sortierung können Sie tun , Schnell Ablehnung (wenn der Knoten , bevor der Knoten kommt in der Art , dann gibt es keinen Weg von nach ). $O(n)$ $n+x$ $x$ $x$ $n+x$

— Peter Taylor
quelle

Das scheint mir nicht wirklich schneller zu sein. Wenn

, könnte der Algorithmus der Frage einfach eine einfache Vorverarbeitung durchführen und NEIN beantworten, wenn es einen isolierten Scheitelpunkt gibt.

m = o (n)

$m=o(n)$

— Serge Gaspers

Wie ist das besser als mein grundlegender Algorithmus?

— Alexandru

@Alexandru, ich denke es ist etwas besser, weil es Bits packt. Das heißt, es ist

wobei

die Wortbreite ist. Es ist nicht klar, ob Sie sich für solche Verbesserungen interessieren.

O ((m + n) n / w)

$O((m+n)n/w)$

w

$w$

— Radu GRIGore

Es ist ein Kompromiss: Sie verwenden O (n * n / w) zusätzlichen Speicher anstelle von O (n).

— Alexandru

@Alexandru, asymptotisch im schlimmsten Fall ist es dasselbe, aber die Analyse des Durchschnittsfalls ist schwierig und was besser ist, hängt möglicherweise von der Statistik der erwarteten Diagrammstruktur ab.

— Peter Taylor

$O(N^2)$

yespath = array(1..N)       // output of the algorithm
                            // initially filled with false
processed = array(1..N)     // processed nodes

// HEURISTIC 1: some preprocessing
for every node u in 1..N
  if (no outbound edges from u) then processed[u] = true
  if (no inbound edges to u+N) then processed[u] = true

for each node u in [1..N]    // MAIN loop 
  if (not processed[u]) then
    collected = [u]          // a list that initially contains u
    visited = array(1..2*N)  // filled with zeroes        
    do a breadth first scan from u
       for each node v found in the search
         set visited[v] = distance from u
         if (v <= N) then add v to collected
    end do

    // HEURISTIC 2: useful collected info on other nodes <= N
    foreach node v in collected
      processed[v] = true
      if ( visited[ v + N ] > 0 and visited[v] < visited[v+N] ) then yespath[v] = true
    end foreach

  end if
end for // MAIN loop

$O(N^2)$ $O(N*k)$ $e > u + N$

Andere Heuristiken können hinzugefügt werden, aber ihre Effizienz (und Effizienz der drei vorgeschlagenen) hängt stark von der Graphstruktur ab.

— Marzio De Biasi
quelle