Comment cosmetics.

[mtp.git] / mtp_graph.cc

diff --git a/mtp_graph.cc b/mtp_graph.cc
index 5b42781..e69d4d6 100644 (file)
--- a/mtp_graph.cc
+++ b/mtp_graph.cc
@@ -275,6 +275,7 @@ void MTPGraph::dp_compute_distances() {
 // pred_edge_toward_source.
 
 void MTPGraph::find_shortest_path() {
+  int heap_size;
   Vertex *v, *tv, **last_slot;
   Edge *e;
   scalar_t d;
@@ -284,20 +285,20 @@ void MTPGraph::find_shortest_path() {
     _vertices[k].pred_edge_toward_source = 0;
   }
 
-  _heap_size = _nb_vertices;
+  heap_size = _nb_vertices;
   _source->distance_from_source = 0;
   _source->decrease_distance_in_heap(_heap);
 
-  do {
+  while(heap_size > 1) {
     // Get the closest to the source
     v = _heap[0];
 
     // Remove it from the heap (swap it with the last_slot in the heap, and
     // update the distance of that one)
-    _heap_size--;
-    last_slot = _heap + _heap_size;
+    heap_size--;
+    last_slot = _heap + heap_size;
     swap(*_heap, *last_slot); swap((*_heap)->heap_slot, (*last_slot)->heap_slot);
-    _heap[0]->increase_distance_in_heap(_heap, _heap + _heap_size);
+    (*_heap)->increase_distance_in_heap(_heap, last_slot);
 
     // Now update the neighbors of the node currently closest to the
     // source
@@ -305,13 +306,13 @@ void MTPGraph::find_shortest_path() {
       d = v->distance_from_source + e->positivized_length;
       tv = e->terminal_vertex;
       if(d < tv->distance_from_source) {
-        ASSERT(tv->heap_slot - _heap < _heap_size);
+        ASSERT(tv->heap_slot < last_slot);
         tv->distance_from_source = d;
         tv->pred_edge_toward_source = e;
         tv->decrease_distance_in_heap(_heap);
       }
     }
-  } while(_heap_size > 0);
+  }
 }
 
 void MTPGraph::find_best_paths(scalar_t *lengths) {
@@ -423,23 +424,15 @@ int MTPGraph::retrieve_one_path(Edge *e, Path *path) {
 
 //////////////////////////////////////////////////////////////////////
 
-static int compare_vertices_on_distance(const void *v1, const void *v2) {
-  scalar_t delta =
-    (*((Vertex **) v1))->distance_from_source -
-    (*((Vertex **) v2))->distance_from_source;
-  if(delta < 0) return -1;
-  else if(delta > 0) return 1;
-  else return 0;
-}
-
 void MTPGraph::compute_dp_ordering() {
   Vertex *v;
   Edge *e;
   int ntv;
 
-  // This method computes for each node the length of the longest link
-  // from the source, and orders the node in _dp_order according to
-  // it. It aborts if the graph is not a DAG.
+  // This method orders the nodes by putting first the ones with no
+  // predecessors, then going on adding nodes whose predecessors have
+  // all been already added. Computing the distances from the source
+  // by visiting nodes in that order is equivalent to DP.
 
   int *nb_predecessors = new int[_nb_vertices];
 
@@ -463,12 +456,15 @@ void MTPGraph::compute_dp_ordering() {
     }
   }
 
-  scalar_t rank = 1;
   while(already_processed < front) {
+    // Here, nodes before already_processed can be ignored, nodes
+    // before front were set to 0 predecessors during the previous
+    // iteration. During this new iteration, we have to visit the
+    // successors of these ones only, since they are the only ones
+    // which may end up with no predecessors.
     new_front = front;
     while(already_processed < front) {
       v = *(already_processed++);
-      v->distance_from_source = rank;
       for(e = v->leaving_edge_list_root; e; e = e->next_leaving_edge) {
         ntv = int(e->terminal_vertex - _vertices);
         nb_predecessors[ntv]--;
@@ -479,7 +475,6 @@ void MTPGraph::compute_dp_ordering() {
       }
     }
     front = new_front;
-    rank++;
   }
 
   if(already_processed < _dp_order + _nb_vertices) {
@@ -488,9 +483,6 @@ void MTPGraph::compute_dp_ordering() {
   }
 
   delete[] nb_predecessors;
-
-  for(int v = 0; v < _nb_vertices; v++) { _dp_order[v] = &_vertices[v]; }
-  qsort(_dp_order, _nb_vertices, sizeof(Vertex *), compare_vertices_on_distance);
 }
 
 //////////////////////////////////////////////////////////////////////