From: Francois Fleuret Date: Sat, 29 Dec 2012 22:23:26 +0000 (+0100) Subject: Removed compute_dp_ranks, added compute_dp_ordering instead. X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=commitdiff_plain;h=1bafc06664224a632f4f607a23a8187f32a1f447;p=mtp.git Removed compute_dp_ranks, added compute_dp_ordering instead. --- diff --git a/mtp_graph.cc b/mtp_graph.cc index 80f9f05..48de3ca 100644 --- 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 --- 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