Add Dijkstra variant without returning predecessors

src/algorithms.rs

@@ -26,20 +26,37 @@ pub struct DijkstraResult<V> {
     pub predecessors: Vec<Option<V>>,
 }
 
-// TODO: Maybe variant of Dijkstra's algorithm without predecessors?
-// TODO: Replace Vec storage with VertexMap, this should make the bound on G::Vertex here obsolete.
 pub fn dijkstra<G>(graph: &G, source: G::Vertex) -> DijkstraResult<G::Vertex>
 where
     G: GraphTopology,
     G::Vertex: Into<usize>,
 {
-    let mut result = DijkstraResult {
-        distances: vec![None; graph.vertex_count()],
-        predecessors: vec![None; graph.vertex_count()],
-    };
+    let mut predecessors = vec![None; graph.vertex_count()];
+    let distances = dijkstra_impl(graph, source, |neighbor, predecessor| {
+        predecessors[neighbor.into()] = Some(predecessor);
+    });
+    DijkstraResult { distances, predecessors }
+}
+
+pub fn dijkstra_distances<G>(graph: &G, source: G::Vertex) -> Vec<Option<u32>>
+where
+    G: GraphTopology,
+    G::Vertex: Into<usize>,
+{
+    dijkstra_impl(graph, source, |_, _| {})
+}
+
+// TODO: Replace Vec storage with VertexMap, this should make the bound on G::Vertex here obsolete.
+fn dijkstra_impl<G, F>(graph: &G, source: G::Vertex, mut on_relax: F) -> Vec<Option<u32>>
+where
+    G: GraphTopology,
+    G::Vertex: Into<usize>,
+    F: FnMut(G::Vertex, G::Vertex),
+{
+    let mut distances = vec![None; graph.vertex_count()];
     let mut heap = BinaryHeap::new();
 
-    result.distances[source.into()] = Some(0);
+    distances[source.into()] = Some(0);
     heap.push(DistanceOrderedVertex {
         vertex: source,
         distance: 0,
@@ -49,14 +66,14 @@ where
         for neighbor in graph.neighbors(v.vertex) {
             // TODO: Add a way to provide custom edge weights for Dijkstra's algorithm.
             let edge_weight = 1;
-            let new_distance = result.distances[v.vertex.into()].unwrap() + edge_weight;
-            if match result.distances[neighbor.into()] {
+            let new_distance = distances[v.vertex.into()].unwrap() + edge_weight;
+            if match distances[neighbor.into()] {
                 None => true,
                 Some(old_distance) if old_distance > new_distance => true,
                 _ => false,
             } {
-                result.distances[neighbor.into()] = Some(new_distance);
-                result.predecessors[neighbor.into()] = Some(v.vertex);
+                distances[neighbor.into()] = Some(new_distance);
+                on_relax(neighbor, v.vertex);
                 heap.push(DistanceOrderedVertex {
                     vertex: neighbor,
                     distance: new_distance,
@@ -64,5 +81,5 @@ where
             }
         }
     }
-    result
+    distances
 }