// Solve the maze using A-star search. Return true if a solution was found.
bool maze::solve() {
boost::static_property_map<distance> weight(1);
// The predecessor map is a vertex-to-vertex mapping.
typedef boost::unordered_map<vertex_descriptor,
vertex_descriptor,
vertex_hash> pred_map;
pred_map predecessor;
boost::associative_property_map<pred_map> pred_pmap(predecessor);
// The distance map is a vertex-to-distance mapping.
typedef boost::unordered_map<vertex_descriptor,
distance,
vertex_hash> dist_map;
dist_map distance;
boost::associative_property_map<dist_map> dist_pmap(distance);
vertex_descriptor s = source();
vertex_descriptor g = goal();
euclidean_heuristic heuristic(g);
astar_goal_visitor visitor(g);
try {
astar_search(m_barrier_grid, s, heuristic,
boost::weight_map(weight).
predecessor_map(pred_pmap).
distance_map(dist_pmap).
visitor(visitor) );
} catch(found_goal fg) {
// Walk backwards from the goal through the predecessor chain adding
// vertices to the solution path.
for (vertex_descriptor u = g; u != s; u = predecessor[u])
m_solution.insert(u);
m_solution.insert(s);
m_solution_length = distance[g];
return true;
}
return false;
}
OutputIterator
sloan_ordering(Graph& g,
typename graph_traits<Graph>::vertex_descriptor s,
typename graph_traits<Graph>::vertex_descriptor e,
OutputIterator permutation,
ColorMap color,
DegreeMap degree,
PriorityMap priority,
Weight W1,
Weight W2)
{
//typedef typename property_traits<DegreeMap>::value_type Degree;
typedef typename property_traits<PriorityMap>::value_type Degree;
typedef typename property_traits<ColorMap>::value_type ColorValue;
typedef color_traits<ColorValue> Color;
typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
typedef typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator vec_iter;
typedef typename graph_traits<Graph>::vertices_size_type size_type;
typedef typename property_map<Graph, vertex_index_t>::const_type VertexID;
//Creating a std-vector for storing the distance from the end vertex in it
typename std::vector<typename graph_traits<Graph>::vertices_size_type> dist(num_vertices(g), 0);
//Wrap a property_map_iterator around the std::iterator
boost::iterator_property_map<vec_iter, VertexID, size_type, size_type&> dist_pmap(dist.begin(), get(vertex_index, g));
breadth_first_search
(g, e, visitor
(
make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) )
)
);
//Creating a property_map for the indices of a vertex
typename property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, g);
//Sets the color and priority to their initial status
unsigned cdeg;
typename graph_traits<Graph>::vertex_iterator ui, ui_end;
for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
{
put(color, *ui, Color::white());
cdeg=get(degree, *ui)+1;
put(priority, *ui, W1*dist[index_map[*ui]]-W2*cdeg );
}
//Priority list
typedef indirect_cmp<PriorityMap, std::greater<Degree> > Compare;
Compare comp(priority);
std::list<Vertex> priority_list;
//Some more declarations
typename graph_traits<Graph>::out_edge_iterator ei, ei_end, ei2, ei2_end;
Vertex u, v, w;
put(color, s, Color::green()); //Sets the color of the starting vertex to gray
priority_list.push_front(s); //Puts s into the priority_list
while ( !priority_list.empty() )
{
priority_list.sort(comp); //Orders the elements in the priority list in an ascending manner
u = priority_list.front(); //Accesses the last element in the priority list
priority_list.pop_front(); //Removes the last element in the priority list
if(get(color, u) == Color::green() )
{
//for-loop over all out-edges of vertex u
for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei)
{
v = target(*ei, g);
put( priority, v, get(priority, v) + W2 ); //updates the priority
if (get(color, v) == Color::white() ) //test if the vertex is inactive
{
put(color, v, Color::green() ); //giving the vertex a preactive status
priority_list.push_front(v); //writing the vertex in the priority_queue
}
}
}
//Here starts step 8
*permutation++ = u; //Puts u to the first position in the permutation-vector
put(color, u, Color::black() ); //Gives u an inactive status
//for loop over all the adjacent vertices of u
for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
v = target(*ei, g);
if (get(color, v) == Color::green() ) { //tests if the vertex is inactive
put(color, v, Color::red() ); //giving the vertex an active status
put(priority, v, get(priority, v)+W2); //updates the priority
//for loop over alll adjacent vertices of v
for (boost::tie(ei2, ei2_end) = out_edges(v, g); ei2 != ei2_end; ++ei2) {
w = target(*ei2, g);
if(get(color, w) != Color::black() ) { //tests if vertex is postactive
put(priority, w, get(priority, w)+W2); //updates the priority
if(get(color, w) == Color::white() ){
put(color, w, Color::green() ); // gives the vertex a preactive status
priority_list.push_front(w); // puts the vertex into the priority queue
} //end if
} //end if
} //end for
} //end if
} //end for
} //end while
return permutation;
}
typename graph_traits<Graph>::vertex_descriptor
sloan_start_end_vertices(Graph& G,
typename graph_traits<Graph>::vertex_descriptor &s,
ColorMap color,
DegreeMap degree)
{
typedef typename property_traits<DegreeMap>::value_type Degree;
typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
typedef typename std::vector< typename graph_traits<Graph>::vertices_size_type>::iterator vec_iter;
typedef typename graph_traits<Graph>::vertices_size_type size_type;
typedef typename property_map<Graph, vertex_index_t>::const_type VertexID;
s = *(vertices(G).first);
Vertex e = s;
Vertex i;
unsigned my_degree = get(degree, s );
unsigned dummy, h_i, h_s, w_i, w_e;
bool new_start = true;
unsigned maximum_degree = 0;
//Creating a std-vector for storing the distance from the start vertex in dist
std::vector<typename graph_traits<Graph>::vertices_size_type> dist(num_vertices(G), 0);
//Wrap a property_map_iterator around the std::iterator
boost::iterator_property_map<vec_iter, VertexID, size_type, size_type&> dist_pmap(dist.begin(), get(vertex_index, G));
//Creating a property_map for the indices of a vertex
typename property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, G);
//Creating a priority queue
typedef indirect_cmp<DegreeMap, std::greater<Degree> > Compare;
Compare comp(degree);
std::priority_queue<Vertex, std::vector<Vertex>, Compare> degree_queue(comp);
//step 1
//Scan for the vertex with the smallest degree and the maximum degree
typename graph_traits<Graph>::vertex_iterator ui, ui_end;
for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
{
dummy = get(degree, *ui);
if(dummy < my_degree)
{
my_degree = dummy;
s = *ui;
}
if(dummy > maximum_degree)
{
maximum_degree = dummy;
}
}
//end 1
do{
new_start = false; //Setting the loop repetition status to false
//step 2
//initialize the the disance std-vector with 0
for(typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0;
//generating the RLS (rooted level structure)
breadth_first_search
(G, s, visitor
(
make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) )
)
);
//end 2
//step 3
//calculating the depth of the RLS
h_s = RLS_depth(dist);
//step 4
//pushing one node of each degree in an ascending manner into degree_queue
std::vector<bool> shrink_trace(maximum_degree, false);
for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
{
dummy = get(degree, *ui);
if( (dist[index_map[*ui]] == h_s ) && ( !shrink_trace[ dummy ] ) )
{
degree_queue.push(*ui);
shrink_trace[ dummy ] = true;
}
}
//end 3 & 4
// step 5
// Initializing w
w_e = (std::numeric_limits<unsigned>::max)();
//end 5
//step 6
//Testing for termination
while( !degree_queue.empty() )
{
i = degree_queue.top(); //getting the node with the lowest degree from the degree queue
degree_queue.pop(); //ereasing the node with the lowest degree from the degree queue
//generating a RLS
for(typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0;
breadth_first_search
(G, i, boost::visitor
(
make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) )
)
);
//Calculating depth and width of the rooted level
h_i = RLS_depth(dist);
w_i = RLS_max_width(dist, h_i);
//Testing for termination
if( (h_i > h_s) && (w_i < w_e) )
{
h_s = h_i;
s = i;
while(!degree_queue.empty()) degree_queue.pop();
new_start = true;
}
else if(w_i < w_e)
{
w_e = w_i;
e = i;
}
}
//end 6
}while(new_start);
return e;
}