Do not return zero weight for root vertex and support root loops

Author: clue

src/ShortestPath/Base.php

@@ -52,7 +52,7 @@ protected function getEdgesToInternal(Vertex $endVertex, array $edges)
     {
         $currentVertex = $endVertex;
         $path = array();
-        while ($currentVertex !== $this->vertex) {
+        do {
             $pre = NULL;
             // check all edges to search for edge that points TO current vertex
             foreach ($edges as $edge) {
@@ -68,7 +68,7 @@ protected function getEdgesToInternal(Vertex $endVertex, array $edges)
             if ($pre === NULL) {
                 throw new OutOfBoundsException('No edge leading to vertex');
             }
-        }
+        } while ($currentVertex !== $this->vertex);
 
         return array_reverse($path);
     }
@@ -198,8 +198,6 @@ public function createGraph()
     protected function getEdgesCheapestPredecesor(array $predecessor)
     {
         $vertices = $this->vertex->getGraph()->getVertices();
-        // start vertex doesn't have a predecessor
-        unset($vertices[$this->vertex->getId()]);
 
         $edges = array();
         foreach ($vertices as $vid => $vertex) {

src/ShortestPath/Dijkstra.php

@@ -16,7 +16,7 @@ public function getEdges()
     {
         $totalCostOfCheapestPathTo  = Array();
         // start node distance
-        $totalCostOfCheapestPathTo[$this->vertex->getId()] = 0;
+        $totalCostOfCheapestPathTo[$this->vertex->getId()] = INF;
 
         // just to get the cheapest vertex in the correct order
         $cheapestVertex = new SplPriorityQueue();
@@ -29,6 +29,8 @@ public function getEdges()
         // mark vertices when their cheapest path has been found
         $usedVertices  = Array();
 
+        $isFirst = true;
+
         // Repeat until all vertices have been marked
         $totalCountOfVertices = $this->vertex->getGraph()->getNumberOfVertices();
         for ($i = 0; $i < $totalCountOfVertices; ++$i) {
@@ -52,8 +54,12 @@ public function getEdges()
                 break;
             }
 
-            // mark this vertex
-            $usedVertices[$currentVertexId] = true;
+            if ($isFirst) {
+                $isFirst = false;
+            } else {
+                // mark this vertex
+                $usedVertices[$currentVertexId] = true;
+            }
 
             // check for all edges of current vertex if there is a cheaper path (or IN OTHER WORDS: Add reachable nodes from currently added node and refresh the current possible distances)
             foreach ($currentVertex->getEdgesOut() as $edge) {
@@ -69,6 +75,9 @@ public function getEdges()
                 if (!isset($usedVertices[$targetVertexId])) {
                     // calculate new cost to vertex
                     $newCostsToTargetVertex = $totalCostOfCheapestPathTo[$currentVertexId] + $weight;
+                    if (is_infinite($newCostsToTargetVertex)) {
+                        $newCostsToTargetVertex = $weight;
+                    }
 
                     if ((!isset($predecesVertexOfCheapestPathTo[$targetVertexId]))
                            // is the new path cheaper?
@@ -88,6 +97,10 @@ public function getEdges()
             }
         }
 
+        if ($totalCostOfCheapestPathTo[$this->vertex->getId()] === INF) {
+            unset($predecesVertexOfCheapestPathTo[$this->vertex->getId()]);
+        }
+
         // algorithm is done, return resulting edges
         return $this->getEdgesCheapestPredecesor($predecesVertexOfCheapestPathTo);
     }

src/ShortestPath/MooreBellmanFord.php

@@ -31,6 +31,9 @@ private function bigStep(array &$edges, array &$totalCostOfCheapestPathTo, array
                 if (isset($totalCostOfCheapestPathTo[$fromVertex->getId()])) {
                     // New possible costs of this path
                     $newCost = $totalCostOfCheapestPathTo[$fromVertex->getId()] + $edge->getWeight();
+                    if (is_infinite($newCost)) {
+                        $newCost = $edge->getWeight();
+                    }
 
                     // No path has been found yet
                     if (!isset($totalCostOfCheapestPathTo[$toVertex->getId()])
@@ -56,21 +59,28 @@ private function bigStep(array &$edges, array &$totalCostOfCheapestPathTo, array
      */
     public function getEdges()
     {
-        // start node distance
-        $totalCostOfCheapestPathTo  = array($this->vertex->getId() => 0);
+        // start node distance, add placeholder weight
+        $totalCostOfCheapestPathTo  = array($this->vertex->getId() => INF);
 
         // predecessor
         $predecessorVertexOfCheapestPathTo  = array($this->vertex->getId() => $this->vertex);
 
-        // repeat (n-1) times
-        $numSteps = $this->vertex->getGraph()->getNumberOfVertices() - 1;
+        // the usal algorithm says we repeat (n-1) times.
+        // but because we also want to check for loop edges on the start vertex,
+        // we have to add an additional step:
+        $numSteps = $this->vertex->getGraph()->getNumberOfVertices();
         $edges = $this->vertex->getGraph()->getEdges();
         $changed = true;
-        // repeat n-1 times
+
         for ($i = 0; $i < $numSteps && $changed; ++$i) {
             $changed = $this->bigStep($edges, $totalCostOfCheapestPathTo, $predecessorVertexOfCheapestPathTo);
         }
 
+        // no cheaper edge to start vertex found => remove placeholder weight
+        if ($totalCostOfCheapestPathTo[$this->vertex->getId()] === INF) {
+            unset($predecessorVertexOfCheapestPathTo[$this->vertex->getId()]);
+        }
+
         // algorithm is done, build graph
         $returnEdges = $this->getEdgesCheapestPredecesor($predecessorVertexOfCheapestPathTo);