add transpose, can call spfa / dijkstra directly, can recover path directly from pre

Author: adamant-pwn

cp-algo/graph/base.hpp

@@ -13,6 +13,17 @@ namespace cp_algo::graph {
         using incidence_list = structures::stack_union<edge_index>;
         graph(int n, int v0 = 0): v0(v0), adj(n) {}
 
+        graph transpose() const {
+            static_assert(mode == directed, "transpose is only defined for directed graphs");
+            graph<edge_t, mode> gt(n(), v0);
+            for(auto v: nodes()) {
+                for(auto e: outgoing(v)) {
+                    node_index u = edge(e).to;
+                    gt.add_edge(u, edge(e).backedge(v));
+                }
+            }
+            return gt;
+        }
         void add_edge(node_index u, edge_t e) {
             adj.push(u, (edge_index)size(E));
             E.push_back(e);
@@ -67,7 +78,7 @@ namespace cp_algo::graph {
             }
         }
         static edge_index opposite_idx(edge_index e) {
-            static_assert(mode == undirected, "opposite_index is only defined for undirected graphs");
+            static_assert(mode == undirected, "opposite_idx is only defined for undirected graphs");
             return e ^ 1;
         }
     private:

cp-algo/graph/shortest_path.hpp

@@ -111,33 +111,42 @@ namespace cp_algo::graph {
         return context;
     }
 
+    template<weighted_graph_type graph>
+    shortest_path_context dijkstra(graph const& g, node_index s) {
+        return sssp_impl<dijkstra_context>(g, s);
+    }
+    template<weighted_graph_type graph>
+    shortest_path_context spfa(graph const& g, node_index s) {
+        return sssp_impl<spfa_context>(g, s);
+    }
+    
     template<weighted_graph_type graph>
     shortest_path_context single_source_shortest_path(graph const& g, node_index s) {
         bool negative_edges = false;
         for (auto e: g.edges()) {
             negative_edges |= e.w < 0;
         }
-        if (negative_edges) {
-            return sssp_impl<spfa_context>(g, s);
-        } else {
-            return sssp_impl<dijkstra_context>(g, s);
-        }
+        return negative_edges ? spfa(g, s) : dijkstra(g, s);
     }
 
-    template<weighted_graph_type graph>
-    std::optional<std::pair<int64_t, std::vector<edge_index>>> shortest_path(graph const& g, node_index s, node_index t) {
-        auto [dist, pre] = single_source_shortest_path(g, s);
-        if (dist[t] == shortest_path_context::inf) {
-            return std::nullopt;
-        }
+    std::vector<edge_index> recover_path(auto const& pre, node_index s, node_index t) {
         std::vector<edge_index> path;
         node_index v = t;
         while(v != s) {
             path.push_back(pre[v].e);
             v = pre[v].u;
         }
         std::ranges::reverse(path);
-        return {{dist[t], path}};
+        return path;
+    }
+
+    template<weighted_graph_type graph>
+    std::optional<std::pair<int64_t, std::vector<edge_index>>> shortest_path(graph const& g, node_index s, node_index t) {
+        auto [dist, pre] = single_source_shortest_path(g, s);
+        if (dist[t] == shortest_path_context::inf) {
+            return std::nullopt;
+        }
+        return {{dist[t], recover_path(pre, s, t)}};
     }
 }
 #endif // CP_ALGO_GRAPH_SHORTEST_PATH_HPP