Add outgoing(v) to graphs, don't store reverse edges in digraphs

Author: adamant-pwn

cp-algo/graph/base.hpp

@@ -1,59 +1,86 @@
 #ifndef CP_ALGO_GRAPH_BASE_HPP
 #define CP_ALGO_GRAPH_BASE_HPP
 #include "edge_types.hpp"
+#include "concepts.hpp"
 #include "../structures/stack_union.hpp"
 #include <ranges>
-#include <vector>
 namespace cp_algo::graph {
     using edge_index = int;
-    enum type {directed = 0, undirected = 1};
-    template<type _undirected, edge_type edge_t = edge_base>
+    template<edge_type _edge_t = edge_base, graph_mode _mode = undirected>
     struct graph {
-        static constexpr bool undirected = _undirected;
+        using edge_t = _edge_t;
+        static constexpr auto mode = _mode;
+        using incidence_list = structures::stack_union<edge_index>;
         graph(int n, int v0 = 0): v0(v0), adj(n) {}
 
         void add_edge(node_index u, edge_t e) {
-            adj.push(u, (edge_index)size(edges));
-            edges.push_back(e);
-            if constexpr (undirected) {
-                adj.push(e.to, (edge_index)size(edges));
+            adj.push(u, (edge_index)size(E));
+            E.push_back(e);
+            if constexpr (mode == undirected) {
+                adj.push(e.to, (edge_index)size(E));
+                E.push_back(e.backedge(u));
             }
-            edges.push_back(e.backedge(u));
+        }
+        void add_edge(node_index u, auto... Args) {
+            add_edge(u, edge_t(Args...));
         }
         void read_edges(node_index m) {
-            adj.reserve(m);
+            adj.reserve(mode == undirected ? 2 * m : m);
             for(edge_index i = 0; i < m; i++) {
                 auto [u, e] = edge_t::read(v0);
                 add_edge(u, e);
             }
         }
-        void call_adjacent(node_index v, auto &&callback, auto &&terminate) const {
-            for(int sv = adj.head[v]; sv && !terminate(); sv = adj.next[sv]) {
-                callback(adj.data[sv]);
-            }
+        auto outgoing(node_index v) const {
+            return adj[v];
         }
-        void call_adjacent(node_index v, auto &&callback) const {
-            call_adjacent(v, callback, [](){return false;});
+        auto nodes() const {
+            return std::views::iota(node_index(0), n());
         }
-        void call_edges(auto &&callback) const {
-            for(edge_index e: edges_view()) {
-                callback(e);
+
+        auto edges() const {
+            if constexpr (mode == undirected) {
+                return E | std::views::stride(2);
+            } else {
+                return E | std::views::all;
             }
         }
-        auto nodes_view() const {
-            return std::views::iota(0, n());
-        }
-        auto edges_view() const {
-            return std::views::iota(0, 2 * m()) | std::views::stride(2);
+        auto edge_indices() const {
+            auto indices = std::views::iota(edge_index(0), edge_index(size(E)));
+            if constexpr (mode == undirected) {
+                return indices | std::views::stride(2);
+            } else {
+                return indices;
+            }
         }
-        auto const& incidence_lists() const {return adj;}
-        edge_t const& edge(edge_index e) const {return edges[e];}
+        incidence_list const& incidence_lists() const {return adj;}
+        edge_t const& edge(edge_index e) const {return E[e];}
         node_index n() const {return (node_index)adj.size();}
-        edge_index m() const {return (edge_index)size(edges) / 2;}
+        edge_index m() const {
+            return (edge_index)size(edges());
+        }
+        static edge_index canonical_idx(edge_index e) {
+            if constexpr (mode == undirected) {
+                return e / 2;
+            } else {
+                return e;
+            }
+        }
+        static edge_index opposite_idx(edge_index e) {
+            static_assert(mode == undirected, "opposite_index is only defined for undirected graphs");
+            return e ^ 1;
+        }
     private:
         node_index v0;
-        std::vector<edge_t> edges;
-        structures::stack_union<edge_index> adj;
+        big_vector<edge_t> E;
+        incidence_list adj;
     };
+    // aliases for most standard cases
+    template<edge_type edge_t = edge_base>
+    using digraph = graph<edge_t, directed>;
+    template<weighted_edge_type edge_t = weighted_edge, graph_mode mode = undirected>
+    using weighted_graph = graph<edge_t, mode>;
+    template<weighted_edge_type edge_t = weighted_edge>
+    using weighted_digraph = digraph<edge_t>;
 }
 #endif // CP_ALGO_GRAPH_BASE_HPP

cp-algo/graph/concepts.hpp

@@ -0,0 +1,41 @@
+#ifndef CP_ALGO_GRAPH_CONCEPTS_HPP
+#define CP_ALGO_GRAPH_CONCEPTS_HPP
+#include "edge_types.hpp"
+#include <type_traits>
+
+namespace cp_algo::graph {
+    // Shared graph mode enum for all graph headers
+    enum graph_mode { directed, undirected };
+    // Traits: true for types that expose `edge_t` and static `mode`
+    template<typename T, typename = void>
+    struct graph_traits : std::false_type {};
+
+    template<typename T>
+    struct graph_traits<T, std::void_t<typename T::edge_t, decltype(T::mode)>> : std::true_type {
+        using edge_t = typename T::edge_t;
+        static constexpr auto mode = T::mode;
+        static constexpr bool is_directed = mode == directed;
+        static constexpr bool is_undirected = mode == undirected;
+        static constexpr bool is_weighted = weighted_edge_type<edge_t>;
+    };
+
+    // Concepts
+    template<typename G>
+    concept graph_type = graph_traits<G>::value;
+
+    template<typename G>
+    concept digraph_type = graph_type<G> && graph_traits<G>::is_directed;
+
+    template<typename G>
+    concept undirected_graph_type = graph_type<G> && graph_traits<G>::is_undirected;
+
+    template<typename G>
+    concept weighted_graph_type = graph_type<G> && graph_traits<G>::is_weighted;
+
+    template<typename G>
+    concept weighted_digraph_type = digraph_type<G> && graph_traits<G>::is_weighted;
+
+    template<typename G>
+    concept weighted_undirected_graph_type = undirected_graph_type<G> && graph_traits<G>::is_weighted;
+}
+#endif // CP_ALGO_GRAPH_CONCEPTS_HPP

cp-algo/graph/cycle.hpp

@@ -2,35 +2,40 @@
 #define CP_ALGO_GRAPH_CYCLE_HPP
 #include "base.hpp"
 #include <algorithm>
-#include <vector>
 namespace cp_algo::graph {
-    std::vector<int> find_cycle(auto const& g) {
-        std::vector<char> state(g.n());
-        std::vector<int> cycle;
-        auto dfs = [&](auto &&self, int v, int pe) -> bool {
-            state[v] = 1;
-            bool found = false;
-            g.call_adjacent(v, [&](int e) {
-                if(e / 2 != pe / 2) {
-                    int u = g.edge(e).to;
-                    if(state[u] == 0) {
-                        if(self(self, u, e)) {
-                            if(g.edge(cycle[0]).to != g.edge(cycle.back() ^ 1).to) {
-                                cycle.push_back(e);
-                            }
-                            found = true;
+    template<graph_type graph>
+    std::vector<edge_index> find_cycle(graph const& g) {
+        enum node_state { unvisited, visiting, visited };
+        std::vector<node_state> state(g.n());
+        std::vector<edge_index> cycle;
+        bool closed = false;
+        auto dfs = [&](this auto &&dfs, node_index v, edge_index ep = -1) -> bool {
+            state[v] = visiting;
+            for(auto e: g.outgoing(v)) {
+                if constexpr (undirected_graph_type<graph>) {
+                    if (ep == graph::opposite_idx(e)) {
+                        continue;
+                    }
+                }
+                node_index u = g.edge(e).to;
+                if(state[u] == unvisited) {
+                    if (dfs(u, e)) {
+                        if (!closed) {
+                            cycle.push_back(e);
+                            closed |= g.edge(cycle[0]).to == v;
                         }
-                    } else if(state[u] == 1) {
-                        cycle = {e};
-                        found = true;
+                        return true;
                     }
+                } else if(state[u] == visiting) {
+                    cycle = {e};
+                    return true;
                 }
-            }, [&found](){return found;});
-            state[v] = 2;
-            return found;
+            }
+            state[v] = visited;
+            return false;
         };
-        for(int i: g.nodes_view()) {
-            if(!state[i] && dfs(dfs, i, -2)) {
+        for(node_index i: g.nodes()) {
+            if(state[i] == unvisited && dfs(i)) {
                 break;
             }
         }

cp-algo/graph/euler.hpp

@@ -2,58 +2,79 @@
 #define CP_ALGO_GRAPH_EULER_HPP
 #include "base.hpp"
 #include <algorithm>
+#include <iostream>
+#include <optional>
 #include <utility>
 #include <vector>
+#include <cassert>
 namespace cp_algo::graph {
-    template<typename graph>
-    int euler_start(graph const& g) {
+    template<graph_type graph>
+    std::optional<node_index> euler_start(graph const& g) {
         std::vector<int> deg(g.n());
-        constexpr bool undirected = graph::undirected;
-        int res = 0;
-        g.call_edges([&](edge_index e) {
-            int u = g.edge(e ^ 1).to;
-            int v = g.edge(e).to;
-            res = u;
-            deg[u]++;
-            deg[v]--;
-        });
-        if constexpr (undirected) {
+        std::optional<node_index> default_start = 0;
+        for(auto v: g.nodes()) {
+            for(auto e: g.outgoing(v)) {
+                deg[v]++;
+                default_start = v;
+                if constexpr (digraph_type<graph>) {
+                    deg[g.edge(e).to]--;
+                }
+            }
+        }
+        if constexpr (undirected_graph_type<graph>) {
             for(auto &it: deg) {
-                it = bool(it % 2);
+                it %= 2;
             }
         }
-        auto nodes = g.nodes_view();
         auto is_start = [&](int v) {return deg[v] > 0;};
-        auto starts = std::ranges::count_if(nodes, is_start);
-        if(starts > 1 + undirected) {
-            res = -1;
-        } else if(starts == 1 + undirected) {
-            auto start = *std::ranges::find_if(nodes, is_start);
-            res = deg[start] == 1 ? start : -1;
+        auto starts = std::ranges::count_if(g.nodes(), is_start);
+        auto need_starts = undirected_graph_type<graph> ? 2 : 1;
+        if(starts > need_starts) {
+            return std::nullopt;
+        } else if(starts == need_starts) {
+            auto start = *std::ranges::find_if(g.nodes(), is_start);
+            if (deg[start] == 1) {
+                return start;
+            } else {
+                return std::nullopt;
+            }
         }
-        return res;
+        return default_start;
     }
-    auto euler_trail(auto const& g) {
-        int v0 = euler_start(g);
-        std::vector<int> trail;
-        if(~v0) {
-            std::vector<bool> used(g.m());
-            auto& adj = g.incidence_lists();
-            auto head = adj.head;
-            auto dfs = [&](auto &&self, int v) -> void {
-                while(head[v]) {
-                    int e = adj.data[std::exchange(head[v], adj.next[head[v]])];
-                    if(!used[e / 2]) {
-                        used[e / 2] = 1;
-                        self(self, g.edge(e).to);
-                        trail.push_back(e);
-                    }
+    // Try finding a trail starting from v0
+    // may be partial if graph is not Eulerian or disconnected
+    template<graph_type graph>
+    std::vector<edge_index> try_euler_trail(graph const& g, node_index v0) {
+        std::vector<edge_index> trail;
+        std::vector<bool> used(g.m());
+        auto head = g.nodes() | std::views::transform([&](auto v) {
+            return begin(g.outgoing(v));
+        }) | std::ranges::to<std::vector>();
+        auto dfs = [&](this auto &&dfs, int v) -> void {
+            while (head[v] != end(g.outgoing(v))) {
+                auto e = *head[v]++;
+                if(!used[graph::canonical_idx(e)]) {
+                    used[graph::canonical_idx(e)] = 1;
+                    dfs(g.edge(e).to);
+                    trail.push_back(e);
                 }
-            };
-            dfs(dfs, v0);
-            std::ranges::reverse(trail);
+            }
+        };
+        dfs(v0);
+        std::ranges::reverse(trail);
+        return trail;
+    }
+    template<graph_type graph>
+    std::optional<std::pair<node_index, std::vector<edge_index>>> euler_trail(graph const& g) {
+        auto v0 = euler_start(g);
+        if (!v0) {
+            return std::nullopt;
+        }
+        auto result = try_euler_trail(g, *v0);
+        if ((edge_index)result.size() != g.m()) {
+            return std::nullopt;
         }
-        return std::pair{v0, trail};
+        return {{*v0, std::move(result)}};
     }
 }
 #endif // CP_ALGO_GRAPH_EULER_HPP

cp-algo/graph/mst.hpp

@@ -2,25 +2,29 @@
 #define CP_ALGO_GRAPH_MST_HPP
 #include "base.hpp"
 #include "../structures/dsu.hpp"
+#include "../util/sort.hpp"
 #include <algorithm>
 namespace cp_algo::graph {
-    template<weighted_edge_type edge_t>
-    auto mst(graph<undirected, edge_t> const& g) {
-        std::vector<std::pair<int64_t, edge_index>> edges;
-        g.call_edges([&](edge_index e) {
-            edges.emplace_back(g.edge(e).w, e);
+    template<weighted_undirected_graph_type graph>
+    std::pair<int64_t, std::vector<edge_index>> mst(graph const& g) {
+        struct edge {
+            int64_t w;
+            edge_index i;
+        };
+        auto edges = g.edge_indices() | std::ranges::to<std::vector>();
+        radix_sort(edges, [&](auto e) {
+            return g.edge(e).w;
         });
-        std::ranges::sort(edges);
         structures::dsu me(g.n());
         int64_t total = 0;
         std::vector<edge_index> mst;
-        for(auto [w, e]: edges) {
-            if(me.uni(g.edge(e ^ 1).to, g.edge(e).to)) {
-                total += w;
-                mst.push_back(e);
+        for(auto e: edges) {
+            if(me.uni(g.edge(e).to, g.edge(graph::opposite_idx(e)).to)) {
+                total += g.edge(e).w;
+                mst.push_back(graph::canonical_idx(e));
             }
         }
-        return std::pair{total, mst};
+        return {total, mst};
     }
 }
 #endif // CP_ALGO_GRAPH_MST_HPP