static bool pruneForwardUseless(NGHolder &h, const nfag_t &g, NFAVertex s, vector<default_color_type> &vertexColor) { // Begin with all vertices set to white, as DFV only marks visited // vertices. fill(vertexColor.begin(), vertexColor.end(), boost::white_color); auto index_map = get(&NFAGraphVertexProps::index, g); depth_first_visit(g, s, make_dfs_visitor(boost::null_visitor()), make_iterator_property_map(vertexColor.begin(), index_map)); vector<NFAVertex> dead; // All non-special vertices that are still white can be removed. for (auto v : vertices_range(g)) { u32 idx = g[v].index; if (!is_special(v, g) && vertexColor[idx] == boost::white_color) { DEBUG_PRINTF("vertex %u is unreachable from %u\n", g[v].index, g[s].index); dead.push_back(v); } } if (dead.empty()) { return false; } DEBUG_PRINTF("removing %zu vertices\n", dead.size()); remove_vertices(dead, h, false); return true; }
void PdfContentsGraph::Write(PdfOutputStream& outStream) { typedef pair<PrintVertexVisitor<on_discover_vertex,true>,PrintVertexVisitor<on_finish_vertex,false> > EVList; dfs_visitor<EVList> vis = make_dfs_visitor( EVList( PrintVertexVisitor<on_discover_vertex,true>(&outStream), PrintVertexVisitor<on_finish_vertex,false>(&outStream) ) ); depth_first_search(m_graph, visitor(vis)); }
typename property_traits<ComponentsMap>::value_type kosaraju_strong_components(Graph& G, ComponentsMap c, FinishTime finish_time, ColorMap color) { function_requires< MutableGraphConcept<Graph> >(); // ... typedef typename graph_traits<Graph>::vertex_descriptor Vertex; typedef typename property_traits<ColorMap>::value_type ColorValue; typedef color_traits<ColorValue> Color; typename property_traits<FinishTime>::value_type time = 0; depth_first_search (G, make_dfs_visitor(stamp_times(finish_time, time, on_finish_vertex())), color); Graph G_T(num_vertices(G)); transpose_graph(G, G_T); typedef typename property_traits<ComponentsMap>::value_type count_type; count_type c_count(0); detail::components_recorder<ComponentsMap> vis(c, c_count); // initialize G_T typename graph_traits<Graph>::vertex_iterator ui, ui_end; for (tie(ui, ui_end) = vertices(G_T); ui != ui_end; ++ui) put(color, *ui, Color::white()); typedef typename property_traits<FinishTime>::value_type D; typedef indirect_cmp< FinishTime, std::less<D> > Compare; Compare fl(finish_time); std::priority_queue<Vertex, std::vector<Vertex>, Compare > Q(fl); typename graph_traits<Graph>::vertex_iterator i, j, iend, jend; tie(i, iend) = vertices(G_T); tie(j, jend) = vertices(G); for ( ; i != iend; ++i, ++j) { put(finish_time, *i, get(finish_time, *j)); Q.push(*i); } while ( !Q.empty() ) { Vertex u = Q.top(); Q.pop(); if (get(color, u) == Color::white()) { depth_first_visit(G_T, u, vis, color); ++c_count; } } return c_count; }
void undirected_dfs(const Graph& g, const bgl_named_params<P, T, R>& params) { typedef typename get_param_type< vertex_color_t, bgl_named_params<P, T, R> >::type C; detail::udfs_dispatch<C>::apply (g, choose_param(get_param(params, graph_visitor), make_dfs_visitor(null_visitor())), choose_param(get_param(params, root_vertex_t()), *vertices(g).first), params, get_param(params, edge_color), get_param(params, vertex_color) ); }
/** Remove any vertices that can't be reached by traversing the graph in * reverse from acceptEod. */ void pruneUnreachable(NGHolder &g) { deque<NFAVertex> dead; if (!hasGreaterInDegree(1, g.acceptEod, g) && !hasGreaterInDegree(0, g.accept, g) && edge(g.accept, g.acceptEod, g).second) { // Trivial case: there are no in-edges to our accepts (other than // accept->acceptEod), so all non-specials are unreachable. for (auto v : vertices_range(g)) { if (!is_special(v, g)) { dead.push_back(v); } } } else { // Walk a reverse graph from acceptEod with Boost's depth_first_visit // call. typedef reverse_graph<NFAGraph, NFAGraph&> RevNFAGraph; RevNFAGraph revg(g.g); map<NFAVertex, default_color_type> colours; depth_first_visit(revg, g.acceptEod, make_dfs_visitor(boost::null_visitor()), make_assoc_property_map(colours)); DEBUG_PRINTF("color map has %zu entries after DFV\n", colours.size()); // All non-special vertices that aren't in the colour map (because they // weren't reached) can be removed. for (auto v : vertices_range(revg)) { if (is_special(v, revg)) { continue; } if (!contains(colours, v)) { dead.push_back(v); } } } if (dead.empty()) { DEBUG_PRINTF("no unreachable vertices\n"); return; } remove_vertices(dead, g, false); DEBUG_PRINTF("removed %zu unreachable vertices\n", dead.size()); }
static vector<NFAVertex> findUnreachable(const NGHolder &g) { const boost::reverse_graph<NFAGraph, const NFAGraph &> revg(g.g); ue2::unordered_map<NFAVertex, boost::default_color_type> colours; colours.reserve(num_vertices(g)); depth_first_visit(revg, g.acceptEod, make_dfs_visitor(boost::null_visitor()), make_assoc_property_map(colours)); // Unreachable vertices are not in the colour map. vector<NFAVertex> unreach; for (auto v : vertices_range(revg)) { if (!contains(colours, v)) { unreach.push_back(v); } } return unreach; }