inline void
dijkstra_shortest_paths
(const VertexListGraph& g,
SourceInputIter s_begin, SourceInputIter s_end,
PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
IndexMap index_map,
Compare compare, Combine combine, DistInf inf, DistZero zero,
DijkstraVisitor vis, ColorMap color)
{
typedef typename property_traits<ColorMap>::value_type ColorValue;
typedef color_traits<ColorValue> Color;
typename graph_traits<VertexListGraph>::vertex_iterator ui, ui_end;
for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
vis.initialize_vertex(*ui, g);
put(distance, *ui, inf);
put(predecessor, *ui, *ui);
put(color, *ui, Color::white());
}
for (SourceInputIter it = s_begin; it != s_end; ++it) {
put(distance, *it, zero);
}
dijkstra_shortest_paths_no_init(g, s_begin, s_end, predecessor, distance,
weight, index_map, compare, combine, zero, vis,
color);
}
inline void
dag_shortest_paths
(const VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
DistanceMap distance, WeightMap weight, ColorMap color,
PredecessorMap pred,
DijkstraVisitor vis, Compare compare, Combine combine,
DistInf inf, DistZero zero)
{
typedef typename graph_traits<VertexListGraph>::vertex_descriptor Vertex;
std::vector<Vertex> rev_topo_order;
rev_topo_order.reserve(num_vertices(g));
// Call 'depth_first_visit', not 'topological_sort', because we don't
// want to traverse the entire graph, only vertices reachable from 's',
// and 'topological_sort' will traverse everything. The logic below
// is the same as for 'topological_sort', only we call 'depth_first_visit'
// and 'topological_sort' calls 'depth_first_search'.
topo_sort_visitor<std::back_insert_iterator<std::vector<Vertex> > >
topo_visitor(std::back_inserter(rev_topo_order));
depth_first_visit(g, s, topo_visitor, color);
typename graph_traits<VertexListGraph>::vertex_iterator ui, ui_end;
for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
put(distance, *ui, inf);
put(pred, *ui, *ui);
}
put(distance, s, zero);
vis.discover_vertex(s, g);
typename std::vector<Vertex>::reverse_iterator i;
for (i = rev_topo_order.rbegin(); i != rev_topo_order.rend(); ++i) {
Vertex u = *i;
vis.examine_vertex(u, g);
typename graph_traits<VertexListGraph>::out_edge_iterator e, e_end;
for (boost::tie(e, e_end) = out_edges(u, g); e != e_end; ++e) {
vis.discover_vertex(target(*e, g), g);
bool decreased = relax(*e, g, weight, pred, distance,
combine, compare);
if (decreased)
vis.edge_relaxed(*e, g);
else
vis.edge_not_relaxed(*e, g);
}
vis.finish_vertex(u, g);
}
}
inline void
parallel_dijkstra_shortest_paths
(const VertexListGraph& g,
RootVertexMap root_vertex_map,
PredecessorMap predecessor_map, DistanceMap distance_map,
WeightMap weight_map, IndexMap index_map,
Compare compare, Combine combine, DistInf inf, DistZero zero,
DijkstraVisitor vis, ColorMap color_map)
{
using boost::vertices;
// TODO VertexList and IncidentGraph CenceptCheck
typedef
typename boost::property_traits<RootVertexMap>::value_type
RootVertex;
typedef
typename boost::graph_traits<VertexListGraph>::vertex_descriptor
Vertex;
boost::function_requires< boost::Convertible<RootVertex, Vertex> >();
typedef typename boost::property_traits<ColorMap>::value_type ColorValue;
typedef boost::color_traits<ColorValue> Color;
typename boost::graph_traits<VertexListGraph>::vertex_iterator vi, vi_end;
for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
vis.initialize_vertex(*vi, g);
if (get(root_vertex_map, *vi) != false) {
put(distance_map, *vi, zero);
}
else {
put(distance_map, *vi, inf);
}
put(predecessor_map, *vi, *vi);
put(color_map, *vi, Color::white());
}
parallel_dijkstra_shortest_paths_no_init
(g, root_vertex_map, predecessor_map, distance_map,
weight_map, index_map, compare, combine, zero, vis, color_map);
}
inline void
dag_shortest_paths
(const VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
DistanceMap distance, WeightMap weight, ColorMap color,
PredecessorMap pred,
DijkstraVisitor vis, Compare compare, Combine combine,
DistInf inf, DistZero zero)
{
typedef typename graph_traits<VertexListGraph>::vertex_descriptor Vertex;
std::vector<Vertex> rev_topo_order;
rev_topo_order.reserve(num_vertices(g));
topological_sort(g, std::back_inserter(rev_topo_order));
typename graph_traits<VertexListGraph>::vertex_iterator ui, ui_end;
for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
put(distance, *ui, inf);
put(pred, *ui, *ui);
}
put(distance, s, zero);
vis.discover_vertex(s, g);
std::vector<Vertex>::reverse_iterator i;
for (i = rev_topo_order.rbegin(); i != rev_topo_order.rend(); ++i) {
Vertex u = *i;
vis.examine_vertex(u, g);
typename graph_traits<VertexListGraph>::out_edge_iterator e, e_end;
for (tie(e, e_end) = out_edges(u, g); e != e_end; ++e) {
vis.discover_vertex(target(*e, g), g);
bool decreased = relax(*e, g, weight, pred, distance,
combine, compare);
if (decreased)
vis.edge_relaxed(*e, g);
else
vis.edge_not_relaxed(*e, g);
}
vis.finish_vertex(u, g);
}
}
void dijkstra_shortest_paths_no_color_map_no_init
(const Graph& graph,
typename graph_traits<Graph>::vertex_descriptor start_vertex,
PredecessorMap predecessor_map,
DistanceMap distance_map,
WeightMap weight_map,
VertexIndexMap index_map,
DistanceCompare distance_compare,
DistanceWeightCombine distance_weight_combine,
DistanceInfinity distance_infinity,
DistanceZero distance_zero,
DijkstraVisitor visitor)
{
typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
typedef typename property_traits<DistanceMap>::value_type Distance;
typedef indirect_cmp<DistanceMap, DistanceCompare> DistanceIndirectCompare;
DistanceIndirectCompare
distance_indirect_compare(distance_map, distance_compare);
// Choose vertex queue type
#if BOOST_GRAPH_DIJKSTRA_USE_RELAXED_HEAP
typedef relaxed_heap<Vertex, DistanceIndirectCompare, VertexIndexMap>
VertexQueue;
VertexQueue vertex_queue(num_vertices(graph),
distance_indirect_compare,
index_map);
#else
// Default - use d-ary heap (d = 4)
typedef
detail::vertex_property_map_generator<Graph, VertexIndexMap, std::size_t>
IndexInHeapMapHelper;
typedef typename IndexInHeapMapHelper::type IndexInHeapMap;
typedef
d_ary_heap_indirect<Vertex, 4, IndexInHeapMap, DistanceMap, DistanceCompare>
VertexQueue;
boost::scoped_array<std::size_t> index_in_heap_map_holder;
IndexInHeapMap index_in_heap =
IndexInHeapMapHelper::build(graph, index_map,
index_in_heap_map_holder);
VertexQueue vertex_queue(distance_map, index_in_heap, distance_compare);
#endif
// Add vertex to the queue
vertex_queue.push(start_vertex);
// Starting vertex will always be the first discovered vertex
visitor.discover_vertex(start_vertex, graph);
while (!vertex_queue.empty()) {
Vertex min_vertex = vertex_queue.top();
vertex_queue.pop();
visitor.examine_vertex(min_vertex, graph);
// Check if any other vertices can be reached
Distance min_vertex_distance = get(distance_map, min_vertex);
if (!distance_compare(min_vertex_distance, distance_infinity)) {
// This is the minimum vertex, so all other vertices are unreachable
return;
}
// Examine neighbors of min_vertex
BGL_FORALL_OUTEDGES_T(min_vertex, current_edge, graph, Graph) {
visitor.examine_edge(current_edge, graph);
// Check if the edge has a negative weight
if (distance_compare(get(weight_map, current_edge), distance_zero)) {
boost::throw_exception(negative_edge());
}
// Extract the neighboring vertex and get its distance
Vertex neighbor_vertex = target(current_edge, graph);
Distance neighbor_vertex_distance = get(distance_map, neighbor_vertex);
bool is_neighbor_undiscovered =
!distance_compare(neighbor_vertex_distance, distance_infinity);
// Attempt to relax the edge
bool was_edge_relaxed = relax(current_edge, graph, weight_map,
predecessor_map, distance_map,
distance_weight_combine, distance_compare);
if (was_edge_relaxed) {
visitor.edge_relaxed(current_edge, graph);
if (is_neighbor_undiscovered) {
visitor.discover_vertex(neighbor_vertex, graph);
vertex_queue.push(neighbor_vertex);
} else {
vertex_queue.update(neighbor_vertex);
}
} else {
visitor.edge_not_relaxed(current_edge, graph);
}
} // end out edge iteration
visitor.finish_vertex(min_vertex, graph);
} // end while queue not empty