|
|
|
|
@ -0,0 +1,629 @@
|
|
|
|
|
// This file is a copy of the file distributed with boost 1.55
|
|
|
|
|
// It is distributed with CGAL to work around a bug in boost 1.54
|
|
|
|
|
// and must be used only with boost 1.54 by including
|
|
|
|
|
// CGAL/boost/graph/dijkstra_shortest_paths.hpp
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//=======================================================================
|
|
|
|
|
// Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
|
|
|
|
|
// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
|
|
|
|
|
//
|
|
|
|
|
// Distributed under the Boost Software License, Version 1.0. (See
|
|
|
|
|
// accompanying file LICENSE_1_0.txt or copy at
|
|
|
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
|
//=======================================================================
|
|
|
|
|
//
|
|
|
|
|
//
|
|
|
|
|
// Revision History:
|
|
|
|
|
// 04 April 2001: Added named parameter variant. (Jeremy Siek)
|
|
|
|
|
// 01 April 2001: Modified to use new <boost/limits.hpp> header. (JMaddock)
|
|
|
|
|
//
|
|
|
|
|
#ifndef BOOST_GRAPH_DIJKSTRA_HPP
|
|
|
|
|
#define BOOST_GRAPH_DIJKSTRA_HPP
|
|
|
|
|
|
|
|
|
|
#include <functional>
|
|
|
|
|
#include <boost/limits.hpp>
|
|
|
|
|
#include <boost/graph/named_function_params.hpp>
|
|
|
|
|
#include <boost/graph/breadth_first_search.hpp>
|
|
|
|
|
#include <boost/graph/relax.hpp>
|
|
|
|
|
#include <boost/pending/indirect_cmp.hpp>
|
|
|
|
|
#include <boost/graph/exception.hpp>
|
|
|
|
|
#include <boost/pending/relaxed_heap.hpp>
|
|
|
|
|
#include <boost/graph/overloading.hpp>
|
|
|
|
|
#include <boost/smart_ptr.hpp>
|
|
|
|
|
#include <boost/graph/detail/d_ary_heap.hpp>
|
|
|
|
|
#include <boost/graph/two_bit_color_map.hpp>
|
|
|
|
|
#include <boost/property_map/property_map.hpp>
|
|
|
|
|
#include <boost/property_map/vector_property_map.hpp>
|
|
|
|
|
#include <boost/type_traits.hpp>
|
|
|
|
|
#include <boost/concept/assert.hpp>
|
|
|
|
|
|
|
|
|
|
#ifdef BOOST_GRAPH_DIJKSTRA_TESTING
|
|
|
|
|
# include <boost/pending/mutable_queue.hpp>
|
|
|
|
|
#endif // BOOST_GRAPH_DIJKSTRA_TESTING
|
|
|
|
|
|
|
|
|
|
namespace boost {
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief Updates a particular value in a queue used by Dijkstra's
|
|
|
|
|
* algorithm.
|
|
|
|
|
*
|
|
|
|
|
* This routine is called by Dijkstra's algorithm after it has
|
|
|
|
|
* decreased the distance from the source vertex to the given @p
|
|
|
|
|
* vertex. By default, this routine will just call @c
|
|
|
|
|
* Q.update(vertex). However, other queues may provide more
|
|
|
|
|
* specialized versions of this routine.
|
|
|
|
|
*
|
|
|
|
|
* @param Q the queue that will be updated.
|
|
|
|
|
* @param vertex the vertex whose distance has been updated
|
|
|
|
|
* @param old_distance the previous distance to @p vertex
|
|
|
|
|
*/
|
|
|
|
|
template<typename Buffer, typename Vertex, typename DistanceType>
|
|
|
|
|
inline void
|
|
|
|
|
dijkstra_queue_update(Buffer& Q, Vertex vertex, DistanceType old_distance)
|
|
|
|
|
{
|
|
|
|
|
(void)old_distance;
|
|
|
|
|
Q.update(vertex);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef BOOST_GRAPH_DIJKSTRA_TESTING
|
|
|
|
|
// This is a misnomer now: it now just refers to the "default heap", which is
|
|
|
|
|
// currently d-ary (d=4) but can be changed by a #define.
|
|
|
|
|
static bool dijkstra_relaxed_heap = true;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
template <class Visitor, class Graph>
|
|
|
|
|
struct DijkstraVisitorConcept {
|
|
|
|
|
void constraints() {
|
|
|
|
|
BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
|
|
|
|
|
vis.initialize_vertex(u, g);
|
|
|
|
|
vis.discover_vertex(u, g);
|
|
|
|
|
vis.examine_vertex(u, g);
|
|
|
|
|
vis.examine_edge(e, g);
|
|
|
|
|
vis.edge_relaxed(e, g);
|
|
|
|
|
vis.edge_not_relaxed(e, g);
|
|
|
|
|
vis.finish_vertex(u, g);
|
|
|
|
|
}
|
|
|
|
|
Visitor vis;
|
|
|
|
|
Graph g;
|
|
|
|
|
typename graph_traits<Graph>::vertex_descriptor u;
|
|
|
|
|
typename graph_traits<Graph>::edge_descriptor e;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template <class Visitors = null_visitor>
|
|
|
|
|
class dijkstra_visitor : public bfs_visitor<Visitors> {
|
|
|
|
|
public:
|
|
|
|
|
dijkstra_visitor() { }
|
|
|
|
|
dijkstra_visitor(Visitors vis)
|
|
|
|
|
: bfs_visitor<Visitors>(vis) { }
|
|
|
|
|
|
|
|
|
|
template <class Edge, class Graph>
|
|
|
|
|
void edge_relaxed(Edge e, Graph& g) {
|
|
|
|
|
invoke_visitors(this->m_vis, e, g, on_edge_relaxed());
|
|
|
|
|
}
|
|
|
|
|
template <class Edge, class Graph>
|
|
|
|
|
void edge_not_relaxed(Edge e, Graph& g) {
|
|
|
|
|
invoke_visitors(this->m_vis, e, g, on_edge_not_relaxed());
|
|
|
|
|
}
|
|
|
|
|
private:
|
|
|
|
|
template <class Edge, class Graph>
|
|
|
|
|
void tree_edge(Edge u, Graph& g) { }
|
|
|
|
|
};
|
|
|
|
|
template <class Visitors>
|
|
|
|
|
dijkstra_visitor<Visitors>
|
|
|
|
|
make_dijkstra_visitor(Visitors vis) {
|
|
|
|
|
return dijkstra_visitor<Visitors>(vis);
|
|
|
|
|
}
|
|
|
|
|
typedef dijkstra_visitor<> default_dijkstra_visitor;
|
|
|
|
|
|
|
|
|
|
namespace detail {
|
|
|
|
|
|
|
|
|
|
template <class UniformCostVisitor, class UpdatableQueue,
|
|
|
|
|
class WeightMap, class PredecessorMap, class DistanceMap,
|
|
|
|
|
class BinaryFunction, class BinaryPredicate>
|
|
|
|
|
struct dijkstra_bfs_visitor
|
|
|
|
|
{
|
|
|
|
|
typedef typename property_traits<DistanceMap>::value_type D;
|
|
|
|
|
typedef typename property_traits<WeightMap>::value_type W;
|
|
|
|
|
|
|
|
|
|
dijkstra_bfs_visitor(UniformCostVisitor vis, UpdatableQueue& Q,
|
|
|
|
|
WeightMap w, PredecessorMap p, DistanceMap d,
|
|
|
|
|
BinaryFunction combine, BinaryPredicate compare,
|
|
|
|
|
D zero)
|
|
|
|
|
: m_vis(vis), m_Q(Q), m_weight(w), m_predecessor(p), m_distance(d),
|
|
|
|
|
m_combine(combine), m_compare(compare), m_zero(zero) { }
|
|
|
|
|
|
|
|
|
|
template <class Edge, class Graph>
|
|
|
|
|
void tree_edge(Edge e, Graph& g) {
|
|
|
|
|
bool decreased = relax(e, g, m_weight, m_predecessor, m_distance,
|
|
|
|
|
m_combine, m_compare);
|
|
|
|
|
if (decreased)
|
|
|
|
|
m_vis.edge_relaxed(e, g);
|
|
|
|
|
else
|
|
|
|
|
m_vis.edge_not_relaxed(e, g);
|
|
|
|
|
}
|
|
|
|
|
template <class Edge, class Graph>
|
|
|
|
|
void gray_target(Edge e, Graph& g) {
|
|
|
|
|
D old_distance = get(m_distance, target(e, g));
|
|
|
|
|
|
|
|
|
|
bool decreased = relax(e, g, m_weight, m_predecessor, m_distance,
|
|
|
|
|
m_combine, m_compare);
|
|
|
|
|
if (decreased) {
|
|
|
|
|
dijkstra_queue_update(m_Q, target(e, g), old_distance);
|
|
|
|
|
m_vis.edge_relaxed(e, g);
|
|
|
|
|
} else
|
|
|
|
|
m_vis.edge_not_relaxed(e, g);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class Vertex, class Graph>
|
|
|
|
|
void initialize_vertex(Vertex u, Graph& g)
|
|
|
|
|
{ m_vis.initialize_vertex(u, g); }
|
|
|
|
|
template <class Edge, class Graph>
|
|
|
|
|
void non_tree_edge(Edge, Graph&) { }
|
|
|
|
|
template <class Vertex, class Graph>
|
|
|
|
|
void discover_vertex(Vertex u, Graph& g) { m_vis.discover_vertex(u, g); }
|
|
|
|
|
template <class Vertex, class Graph>
|
|
|
|
|
void examine_vertex(Vertex u, Graph& g) { m_vis.examine_vertex(u, g); }
|
|
|
|
|
template <class Edge, class Graph>
|
|
|
|
|
void examine_edge(Edge e, Graph& g) {
|
|
|
|
|
// Test for negative-weight edges:
|
|
|
|
|
//
|
|
|
|
|
// Reasons that other comparisons do not work:
|
|
|
|
|
//
|
|
|
|
|
// m_compare(e_weight, D(0)):
|
|
|
|
|
// m_compare only needs to work on distances, not weights, and those
|
|
|
|
|
// types do not need to be the same (bug 8398,
|
|
|
|
|
// https://svn.boost.org/trac/boost/ticket/8398).
|
|
|
|
|
// m_compare(m_combine(source_dist, e_weight), source_dist):
|
|
|
|
|
// if m_combine is project2nd (as in prim_minimum_spanning_tree),
|
|
|
|
|
// this test will claim that the edge weight is negative whenever
|
|
|
|
|
// the edge weight is less than source_dist, even if both of those
|
|
|
|
|
// are positive (bug 9012,
|
|
|
|
|
// https://svn.boost.org/trac/boost/ticket/9012).
|
|
|
|
|
// m_compare(m_combine(e_weight, source_dist), source_dist):
|
|
|
|
|
// would fix project2nd issue, but documentation only requires that
|
|
|
|
|
// m_combine be able to take a distance and a weight (in that order)
|
|
|
|
|
// and return a distance.
|
|
|
|
|
|
|
|
|
|
// W e_weight = get(m_weight, e);
|
|
|
|
|
// sd_plus_ew = source_dist + e_weight.
|
|
|
|
|
// D sd_plus_ew = m_combine(source_dist, e_weight);
|
|
|
|
|
// sd_plus_2ew = source_dist + 2 * e_weight.
|
|
|
|
|
// D sd_plus_2ew = m_combine(sd_plus_ew, e_weight);
|
|
|
|
|
// The test here is equivalent to e_weight < 0 if m_combine has a
|
|
|
|
|
// cancellation law, but always returns false when m_combine is a
|
|
|
|
|
// projection operator.
|
|
|
|
|
if (m_compare(m_combine(m_zero, get(m_weight, e)), m_zero))
|
|
|
|
|
boost::throw_exception(negative_edge());
|
|
|
|
|
// End of test for negative-weight edges.
|
|
|
|
|
|
|
|
|
|
m_vis.examine_edge(e, g);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
template <class Edge, class Graph>
|
|
|
|
|
void black_target(Edge, Graph&) { }
|
|
|
|
|
template <class Vertex, class Graph>
|
|
|
|
|
void finish_vertex(Vertex u, Graph& g) { m_vis.finish_vertex(u, g); }
|
|
|
|
|
|
|
|
|
|
UniformCostVisitor m_vis;
|
|
|
|
|
UpdatableQueue& m_Q;
|
|
|
|
|
WeightMap m_weight;
|
|
|
|
|
PredecessorMap m_predecessor;
|
|
|
|
|
DistanceMap m_distance;
|
|
|
|
|
BinaryFunction m_combine;
|
|
|
|
|
BinaryPredicate m_compare;
|
|
|
|
|
D m_zero;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
} // namespace detail
|
|
|
|
|
|
|
|
|
|
namespace detail {
|
|
|
|
|
template <class Graph, class IndexMap, class Value, bool KnownNumVertices>
|
|
|
|
|
struct vertex_property_map_generator_helper {};
|
|
|
|
|
|
|
|
|
|
template <class Graph, class IndexMap, class Value>
|
|
|
|
|
struct vertex_property_map_generator_helper<Graph, IndexMap, Value, true> {
|
|
|
|
|
typedef boost::iterator_property_map<Value*, IndexMap> type;
|
|
|
|
|
static type build(const Graph& g, const IndexMap& index, boost::scoped_array<Value>& array_holder) {
|
|
|
|
|
array_holder.reset(new Value[num_vertices(g)]);
|
|
|
|
|
std::fill(array_holder.get(), array_holder.get() + num_vertices(g), Value());
|
|
|
|
|
return make_iterator_property_map(array_holder.get(), index);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template <class Graph, class IndexMap, class Value>
|
|
|
|
|
struct vertex_property_map_generator_helper<Graph, IndexMap, Value, false> {
|
|
|
|
|
typedef boost::vector_property_map<Value, IndexMap> type;
|
|
|
|
|
static type build(const Graph& g, const IndexMap& index, boost::scoped_array<Value>& array_holder) {
|
|
|
|
|
return boost::make_vector_property_map<Value>(index);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template <class Graph, class IndexMap, class Value>
|
|
|
|
|
struct vertex_property_map_generator {
|
|
|
|
|
typedef boost::is_base_and_derived<
|
|
|
|
|
boost::vertex_list_graph_tag,
|
|
|
|
|
typename boost::graph_traits<Graph>::traversal_category>
|
|
|
|
|
known_num_vertices;
|
|
|
|
|
typedef vertex_property_map_generator_helper<Graph, IndexMap, Value, known_num_vertices::value> helper;
|
|
|
|
|
typedef typename helper::type type;
|
|
|
|
|
static type build(const Graph& g, const IndexMap& index, boost::scoped_array<Value>& array_holder) {
|
|
|
|
|
return helper::build(g, index, array_holder);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
namespace detail {
|
|
|
|
|
template <class Graph, class IndexMap, bool KnownNumVertices>
|
|
|
|
|
struct default_color_map_generator_helper {};
|
|
|
|
|
|
|
|
|
|
template <class Graph, class IndexMap>
|
|
|
|
|
struct default_color_map_generator_helper<Graph, IndexMap, true> {
|
|
|
|
|
typedef boost::two_bit_color_map<IndexMap> type;
|
|
|
|
|
static type build(const Graph& g, const IndexMap& index) {
|
|
|
|
|
size_t nv = num_vertices(g);
|
|
|
|
|
return boost::two_bit_color_map<IndexMap>(nv, index);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template <class Graph, class IndexMap>
|
|
|
|
|
struct default_color_map_generator_helper<Graph, IndexMap, false> {
|
|
|
|
|
typedef boost::vector_property_map<boost::two_bit_color_type, IndexMap> type;
|
|
|
|
|
static type build(const Graph& g, const IndexMap& index) {
|
|
|
|
|
return boost::make_vector_property_map<boost::two_bit_color_type>(index);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template <class Graph, class IndexMap>
|
|
|
|
|
struct default_color_map_generator {
|
|
|
|
|
typedef boost::is_base_and_derived<
|
|
|
|
|
boost::vertex_list_graph_tag,
|
|
|
|
|
typename boost::graph_traits<Graph>::traversal_category>
|
|
|
|
|
known_num_vertices;
|
|
|
|
|
typedef default_color_map_generator_helper<Graph, IndexMap, known_num_vertices::value> helper;
|
|
|
|
|
typedef typename helper::type type;
|
|
|
|
|
static type build(const Graph& g, const IndexMap& index) {
|
|
|
|
|
return helper::build(g, index);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Call breadth first search with default color map.
|
|
|
|
|
template <class Graph, class SourceInputIter, class DijkstraVisitor,
|
|
|
|
|
class PredecessorMap, class DistanceMap,
|
|
|
|
|
class WeightMap, class IndexMap, class Compare, class Combine,
|
|
|
|
|
class DistZero>
|
|
|
|
|
inline void
|
|
|
|
|
dijkstra_shortest_paths_no_init
|
|
|
|
|
(const Graph& g,
|
|
|
|
|
SourceInputIter s_begin, SourceInputIter s_end,
|
|
|
|
|
PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
|
|
|
|
|
IndexMap index_map,
|
|
|
|
|
Compare compare, Combine combine, DistZero zero,
|
|
|
|
|
DijkstraVisitor vis)
|
|
|
|
|
{
|
|
|
|
|
typedef
|
|
|
|
|
detail::default_color_map_generator<Graph, IndexMap>
|
|
|
|
|
ColorMapHelper;
|
|
|
|
|
typedef typename ColorMapHelper::type ColorMap;
|
|
|
|
|
ColorMap color =
|
|
|
|
|
ColorMapHelper::build(g, index_map);
|
|
|
|
|
dijkstra_shortest_paths_no_init( g, s_begin, s_end, predecessor, distance, weight,
|
|
|
|
|
index_map, compare, combine, zero, vis,
|
|
|
|
|
color);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Call breadth first search with default color map.
|
|
|
|
|
template <class Graph, class DijkstraVisitor,
|
|
|
|
|
class PredecessorMap, class DistanceMap,
|
|
|
|
|
class WeightMap, class IndexMap, class Compare, class Combine,
|
|
|
|
|
class DistZero>
|
|
|
|
|
inline void
|
|
|
|
|
dijkstra_shortest_paths_no_init
|
|
|
|
|
(const Graph& g,
|
|
|
|
|
typename graph_traits<Graph>::vertex_descriptor s,
|
|
|
|
|
PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
|
|
|
|
|
IndexMap index_map,
|
|
|
|
|
Compare compare, Combine combine, DistZero zero,
|
|
|
|
|
DijkstraVisitor vis)
|
|
|
|
|
{
|
|
|
|
|
dijkstra_shortest_paths_no_init(g, &s, &s + 1, predecessor, distance,
|
|
|
|
|
weight, index_map, compare, combine, zero,
|
|
|
|
|
vis);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Call breadth first search
|
|
|
|
|
template <class Graph, class SourceInputIter, class DijkstraVisitor,
|
|
|
|
|
class PredecessorMap, class DistanceMap,
|
|
|
|
|
class WeightMap, class IndexMap, class Compare, class Combine,
|
|
|
|
|
class DistZero, class ColorMap>
|
|
|
|
|
inline void
|
|
|
|
|
dijkstra_shortest_paths_no_init
|
|
|
|
|
(const Graph& g,
|
|
|
|
|
SourceInputIter s_begin, SourceInputIter s_end,
|
|
|
|
|
PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
|
|
|
|
|
IndexMap index_map,
|
|
|
|
|
Compare compare, Combine combine, DistZero zero,
|
|
|
|
|
DijkstraVisitor vis, ColorMap color)
|
|
|
|
|
{
|
|
|
|
|
typedef indirect_cmp<DistanceMap, Compare> IndirectCmp;
|
|
|
|
|
IndirectCmp icmp(distance, compare);
|
|
|
|
|
|
|
|
|
|
typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
|
|
|
|
|
|
|
|
|
|
#ifdef BOOST_GRAPH_DIJKSTRA_TESTING
|
|
|
|
|
if (!dijkstra_relaxed_heap) {
|
|
|
|
|
typedef mutable_queue<Vertex, std::vector<Vertex>, IndirectCmp, IndexMap>
|
|
|
|
|
MutableQueue;
|
|
|
|
|
|
|
|
|
|
MutableQueue Q(num_vertices(g), icmp, index_map);
|
|
|
|
|
detail::dijkstra_bfs_visitor<DijkstraVisitor, MutableQueue, WeightMap,
|
|
|
|
|
PredecessorMap, DistanceMap, Combine, Compare>
|
|
|
|
|
bfs_vis(vis, Q, weight, predecessor, distance, combine, compare, zero);
|
|
|
|
|
|
|
|
|
|
breadth_first_visit(g, s_begin, s_end, Q, bfs_vis, color);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
#endif // BOOST_GRAPH_DIJKSTRA_TESTING
|
|
|
|
|
|
|
|
|
|
#ifdef BOOST_GRAPH_DIJKSTRA_USE_RELAXED_HEAP
|
|
|
|
|
typedef relaxed_heap<Vertex, IndirectCmp, IndexMap> MutableQueue;
|
|
|
|
|
MutableQueue Q(num_vertices(g), icmp, index_map);
|
|
|
|
|
#else // Now the default: use a d-ary heap
|
|
|
|
|
boost::scoped_array<std::size_t> index_in_heap_map_holder;
|
|
|
|
|
typedef
|
|
|
|
|
detail::vertex_property_map_generator<Graph, IndexMap, std::size_t>
|
|
|
|
|
IndexInHeapMapHelper;
|
|
|
|
|
typedef typename IndexInHeapMapHelper::type IndexInHeapMap;
|
|
|
|
|
IndexInHeapMap index_in_heap =
|
|
|
|
|
IndexInHeapMapHelper::build(g, index_map, index_in_heap_map_holder);
|
|
|
|
|
typedef d_ary_heap_indirect<Vertex, 4, IndexInHeapMap, DistanceMap, Compare>
|
|
|
|
|
MutableQueue;
|
|
|
|
|
MutableQueue Q(distance, index_in_heap, compare);
|
|
|
|
|
#endif // Relaxed heap
|
|
|
|
|
|
|
|
|
|
detail::dijkstra_bfs_visitor<DijkstraVisitor, MutableQueue, WeightMap,
|
|
|
|
|
PredecessorMap, DistanceMap, Combine, Compare>
|
|
|
|
|
bfs_vis(vis, Q, weight, predecessor, distance, combine, compare, zero);
|
|
|
|
|
|
|
|
|
|
breadth_first_visit(g, s_begin, s_end, Q, bfs_vis, color);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Call breadth first search
|
|
|
|
|
template <class Graph, class DijkstraVisitor,
|
|
|
|
|
class PredecessorMap, class DistanceMap,
|
|
|
|
|
class WeightMap, class IndexMap, class Compare, class Combine,
|
|
|
|
|
class DistZero, class ColorMap>
|
|
|
|
|
inline void
|
|
|
|
|
dijkstra_shortest_paths_no_init
|
|
|
|
|
(const Graph& g,
|
|
|
|
|
typename graph_traits<Graph>::vertex_descriptor s,
|
|
|
|
|
PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
|
|
|
|
|
IndexMap index_map,
|
|
|
|
|
Compare compare, Combine combine, DistZero zero,
|
|
|
|
|
DijkstraVisitor vis, ColorMap color)
|
|
|
|
|
{
|
|
|
|
|
dijkstra_shortest_paths_no_init(g, &s, &s + 1, predecessor, distance,
|
|
|
|
|
weight, index_map, compare, combine,
|
|
|
|
|
zero, vis, color);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Initialize distances and call breadth first search with default color map
|
|
|
|
|
template <class VertexListGraph, class SourceInputIter, class DijkstraVisitor,
|
|
|
|
|
class PredecessorMap, class DistanceMap,
|
|
|
|
|
class WeightMap, class IndexMap, class Compare, class Combine,
|
|
|
|
|
class DistInf, class DistZero, typename T, typename Tag,
|
|
|
|
|
typename Base>
|
|
|
|
|
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,
|
|
|
|
|
const bgl_named_params<T, Tag, Base>&
|
|
|
|
|
BOOST_GRAPH_ENABLE_IF_MODELS_PARM(VertexListGraph,vertex_list_graph_tag))
|
|
|
|
|
{
|
|
|
|
|
boost::two_bit_color_map<IndexMap> color(num_vertices(g), index_map);
|
|
|
|
|
dijkstra_shortest_paths(g, s_begin, s_end, predecessor, distance, weight,
|
|
|
|
|
index_map, compare, combine, inf, zero, vis,
|
|
|
|
|
color);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Initialize distances and call breadth first search with default color map
|
|
|
|
|
template <class VertexListGraph, class DijkstraVisitor,
|
|
|
|
|
class PredecessorMap, class DistanceMap,
|
|
|
|
|
class WeightMap, class IndexMap, class Compare, class Combine,
|
|
|
|
|
class DistInf, class DistZero, typename T, typename Tag,
|
|
|
|
|
typename Base>
|
|
|
|
|
inline void
|
|
|
|
|
dijkstra_shortest_paths
|
|
|
|
|
(const VertexListGraph& g,
|
|
|
|
|
typename graph_traits<VertexListGraph>::vertex_descriptor s,
|
|
|
|
|
PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
|
|
|
|
|
IndexMap index_map,
|
|
|
|
|
Compare compare, Combine combine, DistInf inf, DistZero zero,
|
|
|
|
|
DijkstraVisitor vis,
|
|
|
|
|
const bgl_named_params<T, Tag, Base>&
|
|
|
|
|
BOOST_GRAPH_ENABLE_IF_MODELS_PARM(VertexListGraph,vertex_list_graph_tag))
|
|
|
|
|
{
|
|
|
|
|
dijkstra_shortest_paths(g, &s, &s + 1, predecessor, distance, weight,
|
|
|
|
|
index_map, compare, combine, inf, zero, vis);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Initialize distances and call breadth first search
|
|
|
|
|
template <class VertexListGraph, class SourceInputIter, class DijkstraVisitor,
|
|
|
|
|
class PredecessorMap, class DistanceMap,
|
|
|
|
|
class WeightMap, class IndexMap, class Compare, class Combine,
|
|
|
|
|
class DistInf, class DistZero, class ColorMap>
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Initialize distances and call breadth first search
|
|
|
|
|
template <class VertexListGraph, class DijkstraVisitor,
|
|
|
|
|
class PredecessorMap, class DistanceMap,
|
|
|
|
|
class WeightMap, class IndexMap, class Compare, class Combine,
|
|
|
|
|
class DistInf, class DistZero, class ColorMap>
|
|
|
|
|
inline void
|
|
|
|
|
dijkstra_shortest_paths
|
|
|
|
|
(const VertexListGraph& g,
|
|
|
|
|
typename graph_traits<VertexListGraph>::vertex_descriptor s,
|
|
|
|
|
PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
|
|
|
|
|
IndexMap index_map,
|
|
|
|
|
Compare compare, Combine combine, DistInf inf, DistZero zero,
|
|
|
|
|
DijkstraVisitor vis, ColorMap color)
|
|
|
|
|
{
|
|
|
|
|
dijkstra_shortest_paths(g, &s, &s + 1, predecessor, distance, weight,
|
|
|
|
|
index_map, compare, combine, inf, zero,
|
|
|
|
|
vis, color);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Initialize distances and call breadth first search
|
|
|
|
|
template <class VertexListGraph, class SourceInputIter,
|
|
|
|
|
class DijkstraVisitor,
|
|
|
|
|
class PredecessorMap, class DistanceMap,
|
|
|
|
|
class WeightMap, class IndexMap, class Compare, class Combine,
|
|
|
|
|
class DistInf, class DistZero>
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
dijkstra_shortest_paths(g, s_begin, s_end, predecessor, distance,
|
|
|
|
|
weight, index_map,
|
|
|
|
|
compare, combine, inf, zero, vis,
|
|
|
|
|
no_named_parameters());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Initialize distances and call breadth first search
|
|
|
|
|
template <class VertexListGraph, class DijkstraVisitor,
|
|
|
|
|
class PredecessorMap, class DistanceMap,
|
|
|
|
|
class WeightMap, class IndexMap, class Compare, class Combine,
|
|
|
|
|
class DistInf, class DistZero>
|
|
|
|
|
inline void
|
|
|
|
|
dijkstra_shortest_paths
|
|
|
|
|
(const VertexListGraph& g,
|
|
|
|
|
typename graph_traits<VertexListGraph>::vertex_descriptor s,
|
|
|
|
|
PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
|
|
|
|
|
IndexMap index_map,
|
|
|
|
|
Compare compare, Combine combine, DistInf inf, DistZero zero,
|
|
|
|
|
DijkstraVisitor vis)
|
|
|
|
|
{
|
|
|
|
|
dijkstra_shortest_paths(g, &s, &s + 1, predecessor, distance,
|
|
|
|
|
weight, index_map,
|
|
|
|
|
compare, combine, inf, zero, vis);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
namespace detail {
|
|
|
|
|
|
|
|
|
|
// Handle defaults for PredecessorMap and
|
|
|
|
|
// Distance Compare, Combine, Inf and Zero
|
|
|
|
|
template <class VertexListGraph, class DistanceMap, class WeightMap,
|
|
|
|
|
class IndexMap, class Params>
|
|
|
|
|
inline void
|
|
|
|
|
dijkstra_dispatch2
|
|
|
|
|
(const VertexListGraph& g,
|
|
|
|
|
typename graph_traits<VertexListGraph>::vertex_descriptor s,
|
|
|
|
|
DistanceMap distance, WeightMap weight, IndexMap index_map,
|
|
|
|
|
const Params& params)
|
|
|
|
|
{
|
|
|
|
|
// Default for predecessor map
|
|
|
|
|
dummy_property_map p_map;
|
|
|
|
|
|
|
|
|
|
typedef typename property_traits<DistanceMap>::value_type D;
|
|
|
|
|
D inf = choose_param(get_param(params, distance_inf_t()),
|
|
|
|
|
(std::numeric_limits<D>::max)());
|
|
|
|
|
|
|
|
|
|
dijkstra_shortest_paths
|
|
|
|
|
(g, s,
|
|
|
|
|
choose_param(get_param(params, vertex_predecessor), p_map),
|
|
|
|
|
distance, weight, index_map,
|
|
|
|
|
choose_param(get_param(params, distance_compare_t()),
|
|
|
|
|
std::less<D>()),
|
|
|
|
|
choose_param(get_param(params, distance_combine_t()),
|
|
|
|
|
closed_plus<D>(inf)),
|
|
|
|
|
inf,
|
|
|
|
|
choose_param(get_param(params, distance_zero_t()),
|
|
|
|
|
D()),
|
|
|
|
|
choose_param(get_param(params, graph_visitor),
|
|
|
|
|
make_dijkstra_visitor(null_visitor())),
|
|
|
|
|
params);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class VertexListGraph, class DistanceMap, class WeightMap,
|
|
|
|
|
class IndexMap, class Params>
|
|
|
|
|
inline void
|
|
|
|
|
dijkstra_dispatch1
|
|
|
|
|
(const VertexListGraph& g,
|
|
|
|
|
typename graph_traits<VertexListGraph>::vertex_descriptor s,
|
|
|
|
|
DistanceMap distance, WeightMap weight, IndexMap index_map,
|
|
|
|
|
const Params& params)
|
|
|
|
|
{
|
|
|
|
|
// Default for distance map
|
|
|
|
|
typedef typename property_traits<WeightMap>::value_type D;
|
|
|
|
|
typename std::vector<D>::size_type
|
|
|
|
|
n = is_default_param(distance) ? num_vertices(g) : 1;
|
|
|
|
|
std::vector<D> distance_map(n);
|
|
|
|
|
|
|
|
|
|
detail::dijkstra_dispatch2
|
|
|
|
|
(g, s, choose_param(distance, make_iterator_property_map
|
|
|
|
|
(distance_map.begin(), index_map,
|
|
|
|
|
distance_map[0])),
|
|
|
|
|
weight, index_map, params);
|
|
|
|
|
}
|
|
|
|
|
} // namespace detail
|
|
|
|
|
|
|
|
|
|
// Named Parameter Variant
|
|
|
|
|
template <class VertexListGraph, class Param, class Tag, class Rest>
|
|
|
|
|
inline void
|
|
|
|
|
dijkstra_shortest_paths
|
|
|
|
|
(const VertexListGraph& g,
|
|
|
|
|
typename graph_traits<VertexListGraph>::vertex_descriptor s,
|
|
|
|
|
const bgl_named_params<Param,Tag,Rest>& params)
|
|
|
|
|
{
|
|
|
|
|
// Default for edge weight and vertex index map is to ask for them
|
|
|
|
|
// from the graph. Default for the visitor is null_visitor.
|
|
|
|
|
detail::dijkstra_dispatch1
|
|
|
|
|
(g, s,
|
|
|
|
|
get_param(params, vertex_distance),
|
|
|
|
|
choose_const_pmap(get_param(params, edge_weight), g, edge_weight),
|
|
|
|
|
choose_const_pmap(get_param(params, vertex_index), g, vertex_index),
|
|
|
|
|
params);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} // namespace boost
|
|
|
|
|
|
|
|
|
|
#ifdef BOOST_GRAPH_USE_MPI
|
|
|
|
|
# include <boost/graph/distributed/dijkstra_shortest_paths.hpp>
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#endif // BOOST_GRAPH_DIJKSTRA_HPP
|
Sébastien Loriot