How to use Boost MST Algorithm on a complete Graph [closed] - c++

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 1 year ago.
Improve this question
I am very new to the BGL. I have the following problem: I've got a very large complete Graph and weights for every edge and need to evaluate a Minimum Spanning Tree.
I would like to use the Boost Graph Libraries implementation. What structures should I use to represent my complete graph and how would I call the Algorithm? Also I'd like to store the resulting subgraph in some graph structure so that I can perform different operations on the MST afterwards.
Thank you very much.

Answer 1

Here's a simple example. I'd suggest an adjacency matrix since the graph is going to be complete, so the matrix is very dense.
using Graph =
boost::adjacency_matrix<boost::undirectedS, boost::no_property,
boost::property<boost::edge_weight_t, double>>;
using Vertex = Graph::vertex_descriptor;
using Edge = Graph::edge_descriptor;
Now let's create a graph
int main() {
Graph g(23);
Picking an arbitrary number (23) of vertices for this example. Let's use randomly generated weights:
auto weight_distribution = std::bind(
std::lognormal_distribution<>{0, 0.25},
std::mt19937{std::random_device{}()});
Creating all the edges to make the graph complete:
for (Vertex v = 0; v < num_vertices(g); ++v)
for (Vertex u = v + 1; u < num_vertices(g); ++u)
add_edge(v, u, 100*weight_distribution(), g);
Now, let's use Prim's algorithm (since all the weights are non-negative):
std::vector<Vertex> parent(num_vertices(g));
prim_minimum_spanning_tree(g, parent.data());
This writes the predecessor for each vertex in the parent vector (which is called the predecessor map).
Adding Some Output
For more interesting results, let's add some checks and output:
assert(std::ranges::all_of(
make_iterator_range(edges(g)),
[ew = get(boost::edge_weight, g)](auto e) { return ew[e] > 0; }));
Making sure the data satisfies the weight pre-condition. You might also do a completeness check depending on how you get your input data.
std::vector<Vertex> parent(num_vertices(g));
std::map<Vertex, double> distance;
auto root = vertex(0, g); // or just 0
Let's pass the optional arguments distance_map and root_vertex:
prim_minimum_spanning_tree(g, parent.data(),
boost::root_vertex(root)
.distance_map(boost::make_assoc_property_map(distance)));
That uses named parameters (starting with boost::root_vertex and chaining with .other_parameter(...).even_more(...). You can of course start with any named parameter).
Now we can use the recorded data:
double total_path_weight = 9;
for (Vertex v = 0; v < num_vertices(g); ++v) {
auto p = parent[v];
auto weight = distance[v];
std::cout << p << " -> " << v << " weight " << weight
<< (p == v ? " ROOT" : "") << "\n";
total_path_weight += weight;
}
std::cout << "Total path weight " << total_path_weight << "\n";
DEMO
Live On Coliru
#include <boost/graph/adjacency_matrix.hpp>
#include <boost/graph/prim_minimum_spanning_tree.hpp>
#include <random>
#include <iostream>
using Graph =
boost::adjacency_matrix<boost::undirectedS, boost::no_property,
boost::property<boost::edge_weight_t, double>>;
using Vertex = Graph::vertex_descriptor;
using Edge = Graph::edge_descriptor;
using boost::make_iterator_range;
int main() {
Graph g(23);
auto weight_distribution = std::bind(std::lognormal_distribution<>{0, 0.25},
std::mt19937{std::random_device{}()});
for (Vertex v = 0; v < num_vertices(g); ++v)
for (Vertex u = v + 1; u < num_vertices(g); ++u)
add_edge(v, u, 100*weight_distribution(), g);
assert(std::ranges::all_of(
make_iterator_range(edges(g)),
[ew = get(boost::edge_weight, g)](auto e) { return ew[e] > 0; }));
std::vector<Vertex> parent(num_vertices(g));
std::map<Vertex, double> distance;
auto root = vertex(0, g); // or just 0
prim_minimum_spanning_tree(g, parent.data(),
boost::root_vertex(root)
.distance_map(boost::make_assoc_property_map(distance)));
double total_path_weight = 9;
for (Vertex v = 0; v < num_vertices(g); ++v) {
auto p = parent[v];
auto weight = distance[v];
std::cout << p << " -> " << v << " weight " << weight
<< (p == v ? " ROOT" : "") << "\n";
total_path_weight += weight;
}
std::cout << "Total path weight " << total_path_weight << "\n";
}
Printing e.g.
0 -> 0 weight 0 ROOT
15 -> 1 weight 64.6241
21 -> 2 weight 62.1609
1 -> 3 weight 69.207
5 -> 4 weight 71.9255
2 -> 5 weight 68.3983
14 -> 6 weight 66.6639
17 -> 7 weight 69.5045
20 -> 8 weight 78.9941
6 -> 9 weight 69.3287
4 -> 10 weight 62.7512
0 -> 11 weight 65.9305
15 -> 12 weight 70.2627
4 -> 13 weight 67.9708
22 -> 14 weight 73.3816
14 -> 15 weight 61.069
6 -> 16 weight 63.5795
5 -> 17 weight 66.0981
6 -> 18 weight 54.6061
14 -> 19 weight 73.9725
5 -> 20 weight 74.7002
0 -> 21 weight 71.8757
17 -> 22 weight 68.6378
Total path weight 1504.64