Question

我有一个有向图，我知道它没有任何循环依赖关系，并且有“终止”节点，即它们具有自定义顶点属性，这是我可以检查的布尔值。每个边缘都使用BGL内置的边缘权重属性加权。

我想要做的是从所有顶点沿着所有可能的路径行走，直到到达所有可以到达的终端节点并跟踪每个终端节点的“加权”边缘权重。我的意思是，通过以下简单示例可以最好地解释以下内容。

从节点4说起，接下来是带有权重的边沿，如果是T（终止点），则是

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

我想返回一个成对的向量，该向量是终结点节点/边缘权重的“加权”组合，在到达每个节点的途中，它们是：

{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}]

“加权”是指每个新步骤都由在特定路径上走过的所有先前边缘权重的乘积加权。

因此，从4到终止节点1，有两条路径。直接边缘为1，权重为0.25。还有一条路径是4-> 6-> 3-> 1，因此为0.5 * 0.18 * 0.33。因此，对于节点1，总权重为0.25 +（0.5 * 0.18 * 0.33）= 0.2797。

再次从4到终止节点2，存在到4-> 5-> 2（0.45 * 0.65）的路径，因此节点2 = 0.2925

最后是4到终止节点7，路径4-> 6-> 7（0.5 * 0.44），因此节点7 = 0.22

在BGL中这是否可能，我想我需要某种自定义访问者/前身吗？

非常感谢任何帮助。

Answer 1

您的示例计算非常混乱。我假设您 meant 可以按照您的描述进行操作：“在到达每个节点的途中加权边缘权重之和” ，因此：

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

这是一条最短路径的问题。如果您例如使用dijkstra_shortest_paths，您要查找的结果将在distance_map中。只需从该地图中选择“终止顶点”即可完成：

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;
}

打印

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}, }

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

1 个答案: