Can I use my own heap in place of the priority_queue used in <boost graph library> dijkstra_shortest_paths? - graph

Question

I want to write a Dijkstra's algorithm, and I like to take advantage of the boost graph library's code, but I want to use my own implementation of binomial heap and heap instead of the default priority queue. This is my first time using downloaded library code, and I just couldn't figure out a way to do this. Does anyone know how to do this or if this is impossible?

Answer 1

Does anyone know how to do this or if this is impossible?
No, dijkstra_shortest_paths doesn't take a queue type.
That doesn't mean it's impossible. Boost's Dijkstra is an application of BFS. BFS does support custom buffer types.
Keep in mind that Dijkstra requires a priority queue that supports the DECREASE-KEY operation
The decrease-key operation can be specialized for your queue type:
/**
* #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);
}
All Dijkstra invocations go through dijkstra_shortest_paths_no_init, which is responsible for invoking the BFS:
// 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;
// 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);
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);
}
Your could replace the d_ary_heap with your own queue in your own entry point wrapper function. (You could bypass existing BGL Dijkstra algorithm entry points, or you could conceivably hack it with an overload that kicks in on your specific argument types (graph type or any of the other arguments)).
Proof Of Concept
E.g. a proof-of-concept that arbitrarily wraps the Graph type. In hindsight it could be much easier to wrap e.g. the comparison predicate instead.
Live On Coliru
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/dijkstra_shortest_paths.hpp>
#include <boost/graph/graph_utility.hpp>
#include <iostream>
#include <queue>
using G = boost::adjacency_list<>;
using V = G::vertex_descriptor;
using E = G::edge_descriptor;
namespace PoC {
template <typename Graph> struct Wrapped : Graph {
using Graph::Graph;
Graph& get() { return *this; }
Graph const& get() const { return *this; }
};
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(Wrapped<Graph> const& 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) {
using namespace boost;
indirect_cmp<DistanceMap, Compare> icmp(distance, compare);
using Vertex = typename graph_traits<Graph>::vertex_descriptor;
// Now the default: use a d-ary heap
boost::scoped_array<std::size_t> index_in_heap_map_holder;
using IndexInHeapMapHelper = detail::vertex_property_map_generator<Graph, IndexMap, std::size_t>;
using IndexInHeapMap = typename IndexInHeapMapHelper::type;
using MutableQueue = d_ary_heap_indirect<Vertex, 4, IndexInHeapMap, DistanceMap, Compare>;
IndexInHeapMap index_in_heap = IndexInHeapMapHelper::build(g, index_map, index_in_heap_map_holder);
MutableQueue Q(distance, index_in_heap, compare);
std::cerr << "SEHE WAS HERE - pretend we use different MutableQueue" << std::endl;
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);
}
}
template <typename G>
struct boost::graph_traits<PoC::Wrapped<G>> : graph_traits<G> {};
template <typename G, typename P>
struct boost::graph_property<PoC::Wrapped<G>, P> : graph_property<G, P> {};
int main() {
PoC::Wrapped<G> g(10);
add_edge(1, 3, g);
add_edge(2, 4, g);
add_edge(3, 2, g);
add_edge(4, 8, g);
add_edge(8, 3, g);
print_graph(g);
std::vector<V> pred(num_vertices(g));
std::priority_queue<V> q;
dijkstra_shortest_paths( //
g, 0,
boost::predecessor_map(pred.data()) //
.weight_map(boost::constant_property_map<E, double>(0.0)) //
.max_priority_queue(q) //
);
}
Printing, as expected:
0 -->
1 --> 3
2 --> 4
3 --> 2
4 --> 8
5 -->
6 -->
7 -->
8 --> 3
9 -->
SEHE WAS HERE - pretend we use different MutableQueue
Notes/Caveat
Note: I see two reasons to report this as an issue/feature request with the library maintainers:
the added code will depend on detail::dijkstra_bfs_visitor; the name implies it's not intended as public interface
conceptually, BGL tries to be generic with regard to algorithms and data-structures; the omission of the queue from algorithm parameters could be an oversight