Updating priorities in a boost::d_ary_heap_indirect - c++

Question

I am using a d_ary_heap_indirect as a priority queue (to process items with the highest priority first) using a property map to store the priorities. However, when I change the values in the priority property map and push vertices that are already in the queue into the queue again, it results in kind of an invalid state where the vertex appears in the queue twice at different positions.
Here is a demo:
#include <iostream>
#include <iomanip>
#include <boost/graph/grid_graph.hpp>
#include <boost/graph/detail/d_ary_heap.hpp>
#include <boost/property_map/property_map.hpp>
#include <cstdlib>
template <typename TQueue>
static void OutputQueue(TQueue queue);
int main(int, char*[])
{
srand((unsigned int)time(NULL));
srand48((unsigned int)time(NULL));
boost::array<std::size_t, 2> lengths = { { 2,2 } };
typedef boost::grid_graph<2> GraphType;
GraphType graph(lengths);
typedef boost::graph_traits<GraphType>::vertex_descriptor Vertex;
typedef boost::property_map<GraphType, boost::vertex_index_t>::const_type GridIndexMapType;
GridIndexMapType gridIndexMap(get(boost::vertex_index, graph));
typedef boost::vector_property_map<std::size_t, GridIndexMapType> IndexInHeapMap;
IndexInHeapMap index_in_heap(gridIndexMap);
typedef boost::graph_traits<GraphType>::vertex_iterator VertexIteratorType;
typedef boost::vector_property_map<float, GridIndexMapType> PriorityMapType;
PriorityMapType priorityMap(gridIndexMap);
VertexIteratorType vertexIterator, vertexIteratorEnd;
typedef std::greater<float> ComparisonFunctor;
typedef boost::d_ary_heap_indirect<Vertex, 4, IndexInHeapMap, PriorityMapType, ComparisonFunctor > MutableQueueType;
ComparisonFunctor comparisonFunctor;
MutableQueueType mutableQueue(priorityMap, index_in_heap, comparisonFunctor);
std::cout << "There are " << mutableQueue.size() << " items in the queue." << std::endl;
// Add random values to the vertices and add them to the queue
for( tie(vertexIterator, vertexIteratorEnd) = vertices(graph); vertexIterator != vertexIteratorEnd; ++vertexIterator)
{
put(priorityMap, *vertexIterator, rand() % 1000);
}
for( tie(vertexIterator, vertexIteratorEnd) = vertices(graph); vertexIterator != vertexIteratorEnd; ++vertexIterator)
{
mutableQueue.push(*vertexIterator);
}
std::cout << "There are " << mutableQueue.size() << " items in the queue." << std::endl;
std::cout << "The priority queue is: " << std::endl;
OutputQueue(mutableQueue);
// Insert another set of random values for each vertex
for( tie(vertexIterator, vertexIteratorEnd) = vertices(graph); vertexIterator != vertexIteratorEnd; ++vertexIterator)
{
float newPriority = rand() % 1000;
std::cout << "New priority for " << vertexIterator->operator[](0) << ", " << vertexIterator->operator[](1) << " " << newPriority << std::endl;
put(priorityMap, *vertexIterator, newPriority);
}
for( tie(vertexIterator, vertexIteratorEnd) = vertices(graph); vertexIterator != vertexIteratorEnd; ++vertexIterator)
{
//mutableQueue.push(*vertexIterator); // This makes sense that the queue would not end up sorted
mutableQueue.push_or_update(*vertexIterator); // I thought this one should work
//mutableQueue.update(*vertexIterator); // This one actually seems to UNsort the queue?
}
std::cout << "There are " << mutableQueue.size() << " items in the queue." << std::endl;
std::cout << "The priority queue is: " << std::endl;
OutputQueue(mutableQueue);
std::cout << std::endl;
return 0;
}
template <typename TQueue>
static void OutputQueue(TQueue queue)
{
while( ! queue.empty() )
{
typename TQueue::value_type u = queue.top();
// These two lines are equivalent
std::cout << "vertex: " << u[0] << " " << u[1] << " priority: " << get(queue.keys(), u) << std::endl;
queue.pop();
}
}
And a demo output:
There are 0 items in the queue.
There are 4 items in the queue.
The priority queue is:
vertex: 1 1 priority: 445
vertex: 0 0 priority: 150
vertex: 0 1 priority: 84
vertex: 1 0 priority: 0
New priority for 0, 0 769
New priority for 1, 0 870
New priority for 0, 1 99
New priority for 1, 1 211
There are 8 items in the queue.
The priority queue is:
vertex: 0 0 priority: 769
vertex: 1 0 priority: 870
vertex: 1 0 priority: 870
vertex: 0 0 priority: 769
vertex: 1 1 priority: 211
vertex: 1 1 priority: 211
vertex: 0 1 priority: 99
vertex: 0 1 priority: 99
The demo simply sets random priority values for every vertex, and pushes them all into the queue. It then does exactly the same thing again. You can see in the output that some of the items appear in the queue at different positions (not back-to-back, as I would expect, since they reference the same priority value in the PriorityMap).
The problem is that item (0,0) (with new priority 769) appears above vertex (1,0) with priority 870. This would cause the items to be processed in the wrong order.
Is there a way to replace an item in the queue when it is pushed instead of adding a second one? (like an std::set instead of the current behavior which is like std::multiset)?
--------- Edit ------------
In the "// Insert another set of random values for each vertex" loop, I replaced the 'mutableQueue.push(*vertexIterator)' with :
mutableQueue.push_or_update(*vertexIterator);
Unfortunately it doesn't do what I'd expect - the output is now:
There are 0 items in the queue.
New priority for 0, 0 150
New priority for 1, 0 522
New priority for 0, 1 27
New priority for 1, 1 883
There are 4 items in the queue.
The priority queue is:
vertex: 1 1 priority: 883
vertex: 1 0 priority: 522
vertex: 0 0 priority: 150
vertex: 0 1 priority: 27
New priority for 0, 0 658
New priority for 1, 0 591
New priority for 0, 1 836
New priority for 1, 1 341
There are 7 items in the queue.
The priority queue is:
vertex: 0 1 priority: 836
vertex: 0 1 priority: 836
vertex: 0 0 priority: 658
vertex: 0 0 priority: 658
vertex: 1 0 priority: 591
vertex: 1 0 priority: 591
vertex: 1 1 priority: 341
Further, replacing the push() with just update() produces:
There are 0 items in the queue.
New priority for 0, 0 806
New priority for 1, 0 413
New priority for 0, 1 592
New priority for 1, 1 861
There are 4 items in the queue.
The priority queue is:
vertex: 1 1 priority: 861
vertex: 0 0 priority: 806
vertex: 0 1 priority: 592
vertex: 1 0 priority: 413
New priority for 0, 0 175
New priority for 1, 0 642
New priority for 0, 1 991
New priority for 1, 1 462
There are 4 items in the queue.
The priority queue is:
vertex: 1 1 priority: 462
vertex: 0 1 priority: 991
vertex: 1 0 priority: 642
vertex: 0 0 priority: 175
There are now only 4 items (like I would expect), but they are not sorted!
----------- Edit - more information --------------
I think there is something going wrong with the index_in_heap map. I added:
std::cout << "Index added: " << get(index_in_heap, v) << std::endl;
after this line:
put(index_in_heap, v, index);
in d_ary_heap_indirect::push(Value).
I also added
std::cout << "Index added caller: " << get(index_in_heap, v) << std::endl;
after the first round of adding values to the queue (after this line:
mutableQueue.push(*vertexIterator);
The output is:
Original priority for 0, 0 641
Index added: 0
Index added caller: 0
Original priority for 1, 0 40
Index added: 1
Index added caller: 1
Original priority for 0, 1 400
Index added: 2
Index added caller: 2
Original priority for 1, 1 664
Index added: 3
Index added caller: 0
I don't understand why this last index is 3 inside the push()
function, but 0 when I query it from the caller?
When I look at the same things inside the update() function, the
index_in_heap just seems to return garbage. That is, I look at the
value of size_type index = get(index_in_heap, v); in update(), and
when it is called with vertex (0,0), the value of 'index' is
4294967295 (when I would expect it to be in the range [0,3]).
Can anyone explain this? Perhaps I am setting up the index_in_heap map incorrectly?

Answer 1

The priority queue won't update its structure when you just change the priorities of the nodes. Once a node is inserted you need to consider its priority constant. If you need to update the priorities you need to tell the priority queue about this. To this end you need to tell it which node gets what new priority.
Unfortunately, tracking some sort of node identification and priority makes the priority queues slow: for a d-heap it is necessay to track where the node moved, making updates relatively expensive. For node-based heaps, e.g., Fibonacci-heaps, the node stays put but the tend to be more expensive to maintain (Fibonacci-heaps have interesting theoretical complexity which, however, only matters for impractically sized problems). I haven't come up with any middle-ground although I implemented all approaches to priority queues I could find described in books.

Answer 2

The d_ary_heap_indirect is designed to only allow priorities to increase. If in the update() and push_or_update() functions you change:
preserve_heap_property_up(index);
to
preserve_heap_property_up(index);
preserve_heap_property_down();
it seems to allow increasing or decreasing the priorities while keeping the queue sorted.