BGL - 按上一步加权边缘权重的自定义访问者

Question

I have a directed graph, which I know doesn't have any circular dependencies and have "termination" nodes ie they have a custom vertex property, which is a bool that I can check. Each edge is weighted using the BGL built-in edge weight property.

What I want to do is walk from any vertex along all possible paths, until it hits all the termination nodes that can be reached and track the "weighted" edge weights of each termination node reached. By this I mean the following is best explained by the following simple example.

Say from node 4 there are following out edges with weights and if T (a termination)

4->1 : 0.25 : T
4->5 : 0.45
4->6 : 0.5
5->2 : 0.65 : T
6->3 : 0.18 
6->7 : 0.44 : T
3->1 : 0.33 : T

I want to return a vector of pairs which is the termination nodes / "weighted" combination of edge weights that were walked on its way to each node, which in this case would be :

{1, 0.25 + (0.5*0.18*0.33) }
{2, (0.45*0.65)}
{7, (0.5*0.44)}
Final Result : [ {1, 0.2797}, {2, 0.2925}, {7, 0.22}]

By "weighted", i mean each new step is weighted by the product of all previous edge weights walked on a particular path.

So from 4 to termination node 1, there are two paths. An direct edge to 1, weighted by 0.25. There is also a path that goes 4->6->3->1, so that is 0.5*0.18*0.33. Therefore, for node 1, we have a total resultant weight of 0.25 + (0.5*0.18*0.33) = 0.2797.

Again from 4 to termination node 2, there is an path to 4->5->2 (0.45*0.65), so node 2 = 0.2925

And finally 4 to termination node 7, path 4->6->7, (0.5*0.44), so node 7 = 0.22

Is this possible in BGL, I presume I need some sort of custom visitor / predecessor?

Any help much appreciated.

Answer 1

Your example calculations are pretty confusing. I'm assuming you meant to do what your description says: "sum of weighted edge weights that were walked on its way to each node" , so:

{1, 0.25}
{2, (0.45+0.65)}
{7, (0.5+0.44)}
Final Result : [ {1, 0.25}, {2, 1.1}, {7, 0.94}]

This is a shortest-paths problem. If you eg use dijkstra_shortest_paths the result you are looking for would be in distance_map . Simply select the "termination vertices" from that map and you're done:

Live On Coliru

//#include <boost/spirit/home/x3.hpp>
#include <boost/graph/adjacency_list.hpp>

using Weight = double;
struct EdgeProps { Weight weight = 0; };

using Graph = boost::adjacency_list<
    boost::vecS, boost::vecS, boost::directedS, boost::no_property, EdgeProps>;

Graph make_sample();

#include <boost/graph/dijkstra_shortest_paths.hpp>
#include <boost/graph/graph_utility.hpp>

int main() {

    auto const g     = make_sample();
    auto const start = vertex(4, g);

    print_graph(g);

    // property-maps maps for dijkstra:
    auto constexpr INF = std::numeric_limits<Weight>::infinity();
    std::vector<Graph::vertex_descriptor> pred(num_vertices(g));
    std::vector<Weight> dist(num_vertices(g), INF);

    dijkstra_shortest_paths(g, start, boost::predecessor_map(pred.data())
            .distance_map(dist.data())
            .weight_map(get(&EdgeProps::weight, g))
            .distance_inf(INF));

    // print results
    std::cout << "Final Result : [ ";

    for (auto vd : boost::make_iterator_range(vertices(g))) {
        if (INF != dist[vd] && 0 == out_degree(vd, g)) {         // if reachable and leaf,
            std::cout << "{" << vd << ", " << dist[vd] << "}, "; // print total distance from start
        }
    }

    std::cout << "}\n";
}

Graph make_sample() {
    Graph g(8);
    add_edge(4, 1, EdgeProps{0.25}, g); // : T
    add_edge(4, 5, EdgeProps{0.45}, g);
    add_edge(4, 6, EdgeProps{0.5},  g);
    add_edge(5, 2, EdgeProps{0.65}, g); // : T
    add_edge(6, 3, EdgeProps{0.18}, g);
    add_edge(6, 7, EdgeProps{0.44}, g); // : T
    add_edge(3, 1, EdgeProps{0.33}, g); // : T
    return g;
}

Prints

0 --> 
1 --> 
2 --> 
3 --> 1 
4 --> 1 5 6 
5 --> 2 
6 --> 3 7 
7 --> 
Final Result : [ {1, 0.25}, {2, 1.1}, {7, 0.94}, }