使用整数索引访问 boost::graph 中的特定边

Posted 2023-02-21

【中文标题】使用整数索引访问 boost::graph 中的特定边

【英文标题】：Accessing specific edges in boost::graph with integer index

【发布时间】：2017-08-29 11:14:15

【问题描述】：

这与我昨天提出的关于使用整数索引访问顶点的问题有关。该线程在这里：Accessing specific vertices in boost::graph

那里的解决方案表明，使用 vecS 作为顶点的类型，确实可以使用整数索引访问特定的顶点。我想知道 boost 是否提供了类似的方法来使用整数索引有效地访问任意边缘。

附件是描述前者（有效访问具有整数索引的顶点）和访问边的代码，该代码基于开发人员显式维护的两个数组from[] 和to[]，分别存储源和目标的边缘。

代码创建以下图表：

#include <boost/config.hpp>
#include <iostream>
#include <fstream>

#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>

using namespace boost;

typedef adjacency_list_traits<vecS, vecS, directedS> Traits;

typedef adjacency_list<
    vecS, vecS, directedS,
    property<
    vertex_name_t, std::string,
    property<vertex_index_t, int,
    property<vertex_color_t, boost::default_color_type,
    property<vertex_distance_t, double,
    property<vertex_predecessor_t, Traits::edge_descriptor> > > > >,

    property<
    edge_index_t, int,
    property<edge_capacity_t, double,
    property<edge_weight_t, double,
    property<edge_residual_capacity_t, double,
    property<edge_reverse_t, Traits::edge_descriptor> > > > > >
    Graph;

int main() 
    int nonodes = 4;
    const int maxnoedges = 4;//I want to avoid using this.
    Graph g(nonodes);

    property_map<Graph, edge_index_t>::type             E = get(edge_index, g);

    int from[maxnoedges], to[maxnoedges];//I want to avoid using this.


    // Create edges
    Traits::edge_descriptor ed;

    int eindex = 0;

    ed = (add_edge(0, 1, g)).first;
    from[eindex] = 0; to[eindex] = 1;//I want to avoid using this.
    E[ed] = eindex++;


    ed = (add_edge(0, 2, g)).first;
    from[eindex] = 0; to[eindex] = 2;//I want to avoid using this.
    E[ed] = eindex++;

    ed = (add_edge(1, 3, g)).first;
    from[eindex] = 1; to[eindex] = 3;//I want to avoid using this.
    E[ed] = eindex++;

    ed = (add_edge(2, 3, g)).first;
    from[eindex] = 2; to[eindex] = 3;//I want to avoid using this.
    E[ed] = eindex++;

    graph_traits < Graph >::out_edge_iterator ei, e_end;
    for (int vindex = 0; vindex < num_vertices(g); vindex++) 
        printf("Number of outedges for vertex %d is %d\n", vindex, out_degree(vindex, g));
        for (tie(ei, e_end) = out_edges(vindex, g); ei != e_end; ++ei)
            printf("From %d to %d\n", source(*ei, g), target(*ei, g));
    

    printf("Number of edges is %d\n", num_edges(g));

    //Is there any efficient method boost provides 
    //in lieu of having to explicitly maintain from and to arrays
    //on part of the developer?
    for (int eindex = 0; eindex < num_edges(g); eindex++)
        printf("Edge %d is from %d to %d\n", eindex, from[eindex], to[eindex]);

代码构建和编译没有错误。带有vindex 的for 循环与out_edges 和out_degree 一起工作正常，将整数索引作为参数。

有没有办法为下一个直接使用 boost::graph 数据结构打印边缘的 for 循环做同样的事情？

我查看了以下处理类似问题的线程：

Boost graph library: Get edge_descriptor or access edge by index of type int

建议的答案是使用unordered_map。与使用 from[] 和 to[] 数组相比，使用它是否有任何权衡？是否有任何其他计算效率高的访问边的方法？

【参考方案1】：

你只能这样做

使用不同的图模型 外部边缘索引

概念

您可能对AdjacencyMatrix concept 感兴趣。它并不完全支持完整的边 ID，但 AdjacencyMatrix 也可以通过源/目标顶点查找边。

要获得真正完整的边描述符，您可能需要编写自己的图形模型类（对一组现有的 BGL 概念进行建模）。您可能还对grid_graph<> 感兴趣（每个顶点有一组固定的编号边，其中顶点是一个网格）。

How to access edge_descriptor with given vertex_descriptor in boost::grid_graph - 您可以设计一个“全局”编号方案，从而获得线性查找时间

邻接表

这是对上一个答案的修改，显示了外部索引。这类似于您的解决方案。我选择了bimap，所以至少你可以“自动”进行反向查找。

// Create edges
boost::bimaps::bimap<int, Graph::edge_descriptor> edge_idx;

auto new_edge_pair = [&,edge_id=0](int from, int to) mutable 
    auto single = [&](int from, int to) 
        auto d = add_edge(from, to, EdgeProperty  edge_id, 4 , g).first;
        if (!edge_idx.insert(edge_id++, d).second)
            throw std::invalid_argument("duplicate key");
        return d;
    ;

    auto a = single(from, to), b = single(to, from);
    rev[a] = b;
    rev[b] = a;
;

new_edge_pair(0, 1);
new_edge_pair(0, 2);
new_edge_pair(1, 3);
new_edge_pair(2, 3);

现在您可以通过边缘 id 进行循环：

auto& by_id = edge_idx.left;
for (auto const& e : by_id) 
    std::cout << "Edge #" << e.first << " is (" << source(e.second, g) << " -> " << target(e.second, g) << ")\n";

您可以通过它的 id 直接查找边缘：

auto ed = by_id.at(random);
std::cout << "Random edge #" << random << " is (" << source(ed, g) << " -> " << target(ed, g) << ")\n";

反向查找有点多余，因为你可以很容易地使用 BGL 来做同样的事情：

std::cout << "Reverse lookup: " << by_desc.at(ed) << "\n"; // reverse, though not very spectacular
std::cout << "Classic property lookup: " << g[ed].id << "\n"; // because it can be done using boost easily

Live On Coliru

#include <boost/graph/adjacency_list.hpp>
#include <boost/property_map/transform_value_property_map.hpp>
#include <boost/graph/boykov_kolmogorov_max_flow.hpp>
#include <functional>
#include <iostream>

#include <boost/bimap.hpp>
#include <random>

std::mt19937 prng  std::random_device() ;

using namespace boost;

struct VertexProperty  std::string name; ;

struct EdgeProperty 
    int id;
    double capacity, residual_capacity;

    EdgeProperty(int id, double cap, double res = 0)
        : id(id), capacity(cap), residual_capacity(res)
     
;

typedef adjacency_list<vecS, vecS, directedS, VertexProperty, EdgeProperty> Graph;

int main() 
    int nonodes = 4;
    Graph g(nonodes);

    // reverse edge map
    auto rev    = make_vector_property_map<Graph::edge_descriptor>(get(&EdgeProperty::id, g));

    // Create edges
    boost::bimaps::bimap<int, Graph::edge_descriptor> edge_idx;

    auto new_edge_pair = [&,edge_id=0](int from, int to) mutable 
        auto single = [&](int from, int to) 
            auto d = add_edge(from, to, EdgeProperty  edge_id, 4 , g).first;
            if (!edge_idx.insert(edge_id++, d).second)
                throw std::invalid_argument("duplicate key");
            return d;
        ;

        auto a = single(from, to), b = single(to, from);
        rev[a] = b;
        rev[b] = a;
    ;

    new_edge_pair(0, 1);
    new_edge_pair(0, 2);
    new_edge_pair(1, 3);
    new_edge_pair(2, 3);

    // property maps
    struct VertexEx 
        default_color_type color;
        double distance;
        Graph::edge_descriptor pred;
    ;

    auto idx    = get(vertex_index, g);
    auto vex    = make_vector_property_map<VertexEx>(idx);
    auto pred   = make_transform_value_property_map(std::mem_fn(&VertexEx::pred),     vex);
    auto color  = make_transform_value_property_map(std::mem_fn(&VertexEx::color),    vex);
    auto dist   = make_transform_value_property_map(std::mem_fn(&VertexEx::distance), vex);

    auto cap    = get(&EdgeProperty::capacity, g);
    auto rescap = get(&EdgeProperty::residual_capacity, g);

    // algorithm
    double flow = boykov_kolmogorov_max_flow(g, cap, rescap, rev, pred, color, dist, idx, 0, 3);
    std::cout << "Flow: " << flow << "\n";

    
        auto& by_id   = edge_idx.left;
        auto& by_desc = edge_idx.right;

        for (auto const& e : edge_idx.left) 
            std::cout << "Edge #" << e.first << " is (" << source(e.second, g) << " -> " << target(e.second, g) << ")\n";
        
        int random = prng() % num_edges(g);
        auto ed = by_id.at(random);
        std::cout << "Random edge #" << random << " is (" << source(ed, g) << " -> " << target(ed, g) << ")\n";

        std::cout << "Reverse lookup: " << by_desc.at(ed) << "\n"; // reverse, though not very spectacular
        std::cout << "Classic property lookup: " << g[ed].id << "\n"; // because it can be done using boost easily
    

打印

Flow: 8
Edge #0 is (0 -> 1)
Edge #1 is (1 -> 0)
Edge #2 is (0 -> 2)
Edge #3 is (2 -> 0)
Edge #4 is (1 -> 3)
Edge #5 is (3 -> 1)
Edge #6 is (2 -> 3)
Edge #7 is (3 -> 2)
Random edge #2 is (0 -> 2)
Reverse lookup: 2
Classic property lookup: 2

邻接矩阵

保持一切不变，除了改变模型：

#include <boost/graph/adjacency_matrix.hpp>
typedef adjacency_matrix<directedS, VertexProperty, EdgeProperty> Graph;

现在您获得了按顶点查找的附加功能：

Live On Coliru

std::cout << "Finding (3, 1) results in Edge #" << by_desc.at(edge(3, 1, g).first) << "\n";

打印

Finding (3, 1) results in Edge #5

【讨论】：

PS 另见boost.org/doc/libs/1_53_0/libs/graph/doc/…

添加了关于不同图形模型/概念的提示

来自计算 POV，您的建议是否可能与简单地使用 from[] 和 to[] 一样有效（或更少或更多）？顺便说一句，感谢您对我上一个问题的详细回答和幽默感。

我认为对于您列出的特定用例，数组更快。这完全取决于规模和访问模式。您始终可以通过使用动态容器并存储 pair<int,int> 而不是单独的数组来改进它

只定义函数，不需要lambda。展示一些想法，包括获取rev 地图作为成员：coliru.stacked-crooked.com/a/8efb2c8488ef8f07