Use edge type class

Author: adamant-pwn

cp-algo/graph/base.hpp

@@ -5,32 +5,64 @@
 #include <ranges>
 #include <vector>
 namespace cp_algo::graph {
+    struct edge_base {
+        int to;
+
+        edge_base() {}
+        edge_base(int v): to(v) {}
+
+        static auto read(int v0 = 0) {
+            int u, v;
+            std::cin >> u >> v;
+            return std::pair{u - v0, edge_base(v - v0)};
+        }
+
+        edge_base backedge(int from) const {
+            return {from};
+        }
+    };
+    template<typename edge_info>
+    concept edge_type = std::is_base_of_v<edge_base, edge_info>;
+
     enum type {directed = 0, undirected = 1};
-    template<type undirected>
+    template<type undirected, edge_type edge_info = edge_base>
     struct graph {
-        graph(int n, int v0 = 0): n(n), v0(v0), adj(n) {}
+        graph(int n, int v0 = 0): _n(n), m(0), v0(v0), adj(n) {}
 
-        void add_edge(int u, int v) {
-            adj.push(u - v0, size(to));
-            to.push_back(v - v0);
+        void add_edge(int u, edge_info e) {
+            m++;
+            adj.push(u, size(edges));
+            edges.push_back(e);
             if constexpr (undirected) {
-                adj.push(v - v0, size(to));
+                adj.push(e.to, size(edges));
             }
-            to.push_back(u - v0);
+            edges.push_back(e.backedge(u));
         }
         void read_edges(int m) {
             for(int i = 0; i < m; i++) {
-                int u, v;
-                std::cin >> u >> v;
-                add_edge(u, v);
+                auto [u, e] = edge_info::read(v0);
+                add_edge(u, e);
+            }
+        }
+        void call_adjacent(int v, auto &&callback, auto &&terminate = [](){return false;}) const {
+            for(int sv = adj.head[v]; sv && !terminate(); sv = adj.next[sv]) {
+                callback(adj.data[sv]);
             }
         }
+        int deg(int v) const {
+            int ans = 0;
+            call_adjacent([&ans](){ans++;});
+            return ans;
+        }
         auto nodes_view() const {
-            return std::views::iota(0, n);
+            return std::views::iota(0, _n);
         }
-
-        int n, v0;
-        std::vector<int> to;
+        edge_info& edge(int e) {return edges[e];}
+        edge_info const& edge(int e) const {return edges[e];}
+        int n() const {return _n;}
+    private:
+        int _n, m, v0;
+        std::vector<edge_info> edges;
         data_structures::stack_union<int> adj;
     };
 }

cp-algo/graph/cycle.hpp

@@ -5,29 +5,29 @@
 #include <vector>
 namespace cp_algo::graph {
     std::vector<int> find_cycle(auto const& g) {
-        std::vector<char> state(g.n);
+        std::vector<char> state(g.n());
         std::vector<int> cycle;
         auto dfs = [&](auto &&self, int v, int pe) -> bool {
             state[v] = 1;
-            for(int sv = g.adj.head[v]; sv; sv = g.adj.next[sv]) {
-                int e = g.adj.data[sv];
+            bool found = false;
+            g.call_adjacent(v, [&](int e) {
                 if(e / 2 != pe / 2) {
-                    auto u = g.to[e];
+                    int u = g.edge(e).to;
                     if(state[u] == 0) {
                         if(self(self, u, e)) {
-                            if(g.to[cycle[0]] != g.to[cycle.back() ^ 1]) {
+                            if(g.edge(cycle[0]).to != g.edge(cycle.back() ^ 1).to) {
                                 cycle.push_back(e);
                             }
-                            return true;
+                            found = true;
                         }
                     } else if(state[u] == 1) {
                         cycle = {e};
-                        return true;
+                        found = true;
                     }
                 }
-            }
+            }, [&found](){return found;});
             state[v] = 2;
-            return false;
+            return found;
         };
         for(int i: g.nodes_view()) {
             if(!state[i] && dfs(dfs, i, -2)) {

verify/graph/cycle_undirected.test.cpp

@@ -19,7 +19,7 @@ void solve() {
     } else {
         ranges::reverse(res);
         cout << size(res) << "\n";
-        for(auto it: res) {cout << g.to[it] << ' ';}
+        for(auto it: res) {cout << g.edge(it).to << ' ';}
         cout << "\n";
         for(auto it: res) {cout << it / 2 << ' ';}
         cout << "\n";