Removed compute_dp_ranks, added compute_dp_ordering instead.

diff --git a/mtp_graph.cc b/mtp_graph.cc
index 80f9f05..48de3ca 100644 (file)
--- a/mtp_graph.cc
+++ b/mtp_graph.cc
@@ -173,9 +173,7 @@ MTPGraph::MTPGraph(int nb_vertices, int nb_edges,
   paths = 0;
   nb_paths = 0;
 
-  compute_dp_ranks();
-  for(int v = 0; v < _nb_vertices; v++) { _dp_order[v] = &_vertices[v]; }
-  qsort(_dp_order, _nb_vertices, sizeof(Vertex *), compare_vertices_on_distance);
+  compute_dp_ordering();
 }
 
 MTPGraph::~MTPGraph() {
@@ -189,74 +187,6 @@ MTPGraph::~MTPGraph() {
 
 //////////////////////////////////////////////////////////////////////
 
-void MTPGraph::compute_dp_ranks() {
-  Vertex *v;
-  Edge *e;
-  int tv;
-
-  // This procedure computes for each node the longest link from the
-  // source and abort if the graph is not a DAG. It works by removing
-  // successively nodes without predecessor: At the first iteration it
-  // removes the source, then the nodes with incoming edge only from
-  // the source, etc. If it can remove all the nodes that way, the
-  // graph is a DAG. If at some point it can not remove node anymore
-  // and there are some remaining nodes, the graph is not a DAG. The
-  // rank of a node is the iteration at which is it removed, and we
-  // set the distance_from_source fields to this value.
-
-  int *nb_predecessors = new int[_nb_vertices];
-  Vertex **bunch = new Vertex *[_nb_vertices];
-
-  Vertex **already_processed = bunch, **front = bunch, **fresh = bunch;
-
-  for(int k = 0; k < _nb_vertices; k++) {
-    nb_predecessors[k] = 0;
-  }
-
-  for(int k = 0; k < _nb_vertices; k++) {
-    v = &_vertices[k];
-    for(e = v->leaving_edge_list_root; e; e = e->next_leaving_edge) {
-      tv = int(e->terminal_vertex - _vertices);
-      nb_predecessors[tv]++;
-    }
-  }
-
-  for(int k = 0; k < _nb_vertices; k++) {
-    if(nb_predecessors[k] == 0) {
-      *(front++) = _vertices + k;
-    }
-  }
-
-  scalar_t rank = 1;
-  while(already_processed < front) {
-    fresh = 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) {
-        tv = int(e->terminal_vertex - _vertices);
-        nb_predecessors[tv]--;
-        ASSERT(nb_predecessors[tv] >= 0);
-        if(nb_predecessors[tv] == 0) {
-          *(fresh++) = e->terminal_vertex;
-        }
-      }
-    }
-    front = fresh;
-    rank++;
-  }
-
-  if(already_processed < bunch + _nb_vertices) {
-    cerr << __FILE__ << ": The graph is not a DAG." << endl;
-    abort();
-  }
-
-  delete[] nb_predecessors;
-  delete[] bunch;
-}
-
-//////////////////////////////////////////////////////////////////////
-
 void MTPGraph::print(ostream *os) {
   for(int k = 0; k < _nb_edges; k++) {
     Edge *e = &_edges[k];
@@ -498,6 +428,71 @@ int MTPGraph::retrieve_one_path(Edge *e, Path *path) {
   return l;
 }
 
+//////////////////////////////////////////////////////////////////////
+
+void MTPGraph::compute_dp_ordering() {
+  Vertex *v;
+  Edge *e;
+  int tv;
+
+  // This procedure computes for each node the longest link from the
+  // source, and abort if the graph is not a DAG, and order the node
+  // in _dp_order according to that value.
+
+  int *nb_predecessors = new int[_nb_vertices];
+
+  Vertex **already_processed = _dp_order, **front = _dp_order, **new_front = _dp_order;
+
+  for(int k = 0; k < _nb_vertices; k++) {
+    nb_predecessors[k] = 0;
+  }
+
+  for(int k = 0; k < _nb_vertices; k++) {
+    v = &_vertices[k];
+    for(e = v->leaving_edge_list_root; e; e = e->next_leaving_edge) {
+      tv = int(e->terminal_vertex - _vertices);
+      nb_predecessors[tv]++;
+    }
+  }
+
+  for(int k = 0; k < _nb_vertices; k++) {
+    if(nb_predecessors[k] == 0) {
+      *(front++) = _vertices + k;
+    }
+  }
+
+  scalar_t rank = 1;
+  while(already_processed < front) {
+    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) {
+        tv = int(e->terminal_vertex - _vertices);
+        nb_predecessors[tv]--;
+        ASSERT(nb_predecessors[tv] >= 0);
+        if(nb_predecessors[tv] == 0) {
+          *(new_front++) = e->terminal_vertex;
+        }
+      }
+    }
+    front = new_front;
+    rank++;
+  }
+
+  if(already_processed < _dp_order + _nb_vertices) {
+    cerr << __FILE__ << ": The graph is not a DAG." << endl;
+    abort();
+  }
+
+  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);
+}
+
+//////////////////////////////////////////////////////////////////////
+
 void MTPGraph::retrieve_disjoint_paths() {
   Edge *e;
   int p, l;

diff --git a/mtp_graph.h b/mtp_graph.h
index 54037e0..e0f40e9 100644 (file)
--- a/mtp_graph.h
+++ b/mtp_graph.h
@@ -36,9 +36,6 @@ class Vertex;
 class Edge;
 
 class MTPGraph {
-  // Set the distance_from_source fields to the number of DP
-  // iterations needed to update it. Abort if the graph is not a DAG.
-  void compute_dp_ranks();
 
   // Uses the estimated vertex distances to the source to make all the
   // edge lengths positive, resulting in an identical added value to
@@ -80,6 +77,8 @@ class MTPGraph {
   // the original graph (which has to be a DAG)
   Vertex **_dp_order;
 
+  // Fills _dp_order
+  void compute_dp_ordering();
 public:
 
   // These variables are filled when retrieve_disjoint_paths is called