- In the Prim's MST algorithm implementation:

  - Removed the negative weight check
  - Enqueueing edges only if the target vertex in a current iteration is not yet visited
- Improved vertex degree calculating for the adjacency matrix representation

Author: SpectraL519

include/gl/algorithm/mst.hpp

@@ -84,9 +84,12 @@ template <
         if (visited[target_id])
             continue;
 
-            visited[target_id] = true;
-            ++n_vertices_in_mst;
-        }
+        // add the minimum weight edge to the mst
+        mst.edges.emplace_back(min_edge);
+        mst.weight += min_weight;
+
+        visited[target_id] = true;
+        ++n_vertices_in_mst;
 
         // enqueue all edges adjacent to the `target` vertex if they lead to unvisited verties
         for (const auto& edge : graph.adjacent_edges(target_id))

include/gl/impl/specialized/adjacency_matrix.hpp

@@ -78,7 +78,12 @@ struct directed_adjacency_matrix {
     [[nodiscard]] gl_attr_force_inline static types::size_type degree(
         const impl_type& self, const types::id_type vertex_id
     ) {
-        return in_degree(self, vertex_id) + out_degree(self, vertex_id);
+        types::size_type deg = constants::zero;
+        for (types::id_type i = constants::initial_id; i < self._matrix.size(); ++i)
+            deg += static_cast<types::size_type>(self._matrix[vertex_id][i] != nullptr)
+                 + static_cast<types::size_type>(self._matrix[i][vertex_id] != nullptr);
+
+        return deg;
     }
 
     [[nodiscard]] static std::vector<types::size_type> in_degree_map(const impl_type& self) {
@@ -182,11 +187,11 @@ struct undirected_adjacency_matrix {
     [[nodiscard]] gl_attr_force_inline static types::size_type degree(
         const impl_type& self, const types::id_type vertex_id
     ) {
-        types::size_type degree = constants::default_size;
-        for (const auto& edge : self._matrix[vertex_id])
-            if (edge)
-                degree += constants::one + static_cast<types::size_type>(edge->is_loop());
-        return degree;
+        const auto& loop = self._matrix[vertex_id][vertex_id];
+        return std::ranges::count_if(
+                   self._matrix[vertex_id], [](const auto& edge) { return edge != nullptr; }
+               )
+             + static_cast<types::size_type>(loop and loop->is_loop());
     }
 
     [[nodiscard]] gl_attr_force_inline static std::vector<types::size_type> in_degree_map(

tests/source/gl/test_alg_mst.cpp

@@ -23,21 +23,7 @@ TEST_CASE_TEMPLATE_DEFINE(
     using weight_type = typename sut_type::edge_properties_type::weight_type;
     using distance_type = weight_type;
 
-    static_assert(gl::type_traits::c_weight_properties_type<
-                  typename sut_type::edge_properties_type>);
-
-    SUBCASE("should throw if there is an edge with a negative weight") {
-        const auto sut = lib::topology::clique<sut_type>(constants::n_elements_alg);
-        sut.get_edge(constants::vertex_id_1, constants::vertex_id_2)
-            .value()
-            .get()
-            .properties.weight = -static_cast<weight_type>(constants::n_elements_alg);
-
-        CHECK_THROWS_AS(
-            func::discard_result(lib::algorithm::prim_mst(sut, constants::vertex_id_1)),
-            std::invalid_argument
-        );
-    }
+    static_assert(gl::type_traits::c_weight_properties_type<typename sut_type::edge_properties_type>);
 
     SUBCASE("should return a proper mst descriptor for a valid graph") {
         using vertex_id_pair = std::pair<gl::types::id_type, gl::types::id_type>;