Euler trail detection

Author: adamant-pwn

cp-algo/graph/base.hpp

@@ -25,16 +25,17 @@ namespace cp_algo::graph {
     concept edge_type = std::is_base_of_v<edge_base, edge_info>;
 
     enum type {directed = 0, undirected = 1};
-    template<type undirected, edge_type edge_info = edge_base>
+    template<type _undirected, edge_type edge_info = edge_base>
     struct graph {
-        graph(int n, int v0 = 0): _n(n), m(0), v0(v0), adj(n) {}
+        static constexpr bool undirected = _undirected;
+        graph(int n, int v0 = 0): _n(n), _m(0), v0(v0), _adj(n) {}
 
         void add_edge(int u, edge_info e) {
-            m++;
-            adj.push(u, size(edges));
+            _m++;
+            _adj.push(u, size(edges));
             edges.push_back(e);
             if constexpr (undirected) {
-                adj.push(e.to, size(edges));
+                _adj.push(e.to, size(edges));
             }
             edges.push_back(e.backedge(u));
         }
@@ -44,26 +45,30 @@ namespace cp_algo::graph {
                 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]);
+        void call_adjacent(int v, auto &&callback, auto &&terminate) 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;
+        void call_adjacent(int v, auto &&callback) const {
+            call_adjacent(v, callback, [](){return false;});
+        }
+        void call_edges(auto &&callback) const {
+            for(int v: nodes_view()) {
+                call_adjacent(v, [&](int e) {callback(v, e);});
+            }
         }
         auto nodes_view() const {
             return std::views::iota(0, _n);
         }
-        edge_info& edge(int e) {return edges[e];}
-        edge_info const& edge(int e) const {return edges[e];}
+        auto const& incidence_lists() const {return _adj;}
+        auto const& edge(int e) const {return edges[e];}
         int n() const {return _n;}
+        int m() const {return _m;}
     private:
-        int _n, m, v0;
+        int _n, _m, v0;
         std::vector<edge_info> edges;
-        data_structures::stack_union<int> adj;
+        data_structures::stack_union<int> _adj;
     };
 }
 #endif // CP_ALGO_GRAPH_BASE_HPP

cp-algo/graph/euler.hpp

@@ -0,0 +1,57 @@
+#ifndef CP_ALGO_GRAPH_EULER_HPP
+#define CP_ALGO_GRAPH_EULER_HPP
+#include "base.hpp"
+#include <algorithm>
+#include <utility>
+#include <vector>
+namespace cp_algo::graph {
+    template<typename graph>
+    int euler_start(graph const& g) {
+        std::vector<int> deg(g.n());
+        constexpr bool undirected = graph::undirected;
+        int res = 0;
+        g.call_edges([&](int u, int e) {
+            res = u;
+            if constexpr (undirected) {
+                deg[u] ^= 1;
+            } else {
+                deg[u]++;
+                deg[g.edge(e).to]--;
+            }
+        });
+        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;
+        }
+        return res;
+    }
+    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;
+                        int u = g.edge(e).to;
+                        self(self, u);
+                        trail.push_back(e);
+                    }
+                }
+            };
+            dfs(dfs, v0);
+            std::ranges::reverse(trail);
+        }
+        return std::pair{v0, trail};
+    }
+}
+#endif // CP_ALGO_GRAPH_EULER_HPP

verify/graph/euler_directed.test.cpp

@@ -0,0 +1,38 @@
+// @brief Eulerian Trail (Directed)
+#define PROBLEM "https://judge.yosupo.jp/problem/eulerian_trail_directed"
+#pragma GCC optimize("Ofast,unroll-loops")
+#pragma GCC target("tune=native")
+#include "cp-algo/graph/euler.hpp"
+#include <bits/stdc++.h>
+
+using namespace std;
+using namespace cp_algo::graph;
+
+void solve() {
+    int n, m;
+    cin >> n >> m;
+    graph<directed> g(n);
+    g.read_edges(m);
+    auto [v0, es] = euler_trail(g);
+    if(ssize(es) != m) {
+        cout << "No" << "\n";
+    } else {
+        cout << "Yes" << "\n";
+        cout << v0 << ' ';
+        for(auto e: es) {cout << g.edge(e).to << ' ';}
+        cout << "\n";
+        for(auto e: es) {cout << e / 2 << ' ';}
+        cout << "\n";
+    }
+}
+
+signed main() {
+    //freopen("input.txt", "r", stdin);
+    ios::sync_with_stdio(0);
+    cin.tie(0);
+    int t = 1;
+    cin >> t;
+    while(t--) {
+        solve();
+    }
+}

verify/graph/euler_undirected.test.cpp

@@ -0,0 +1,38 @@
+// @brief Eulerian Trail (Undirected)
+#define PROBLEM "https://judge.yosupo.jp/problem/eulerian_trail_undirected"
+#pragma GCC optimize("Ofast,unroll-loops")
+#pragma GCC target("tune=native")
+#include "cp-algo/graph/euler.hpp"
+#include <bits/stdc++.h>
+
+using namespace std;
+using namespace cp_algo::graph;
+
+void solve() {
+    int n, m;
+    cin >> n >> m;
+    graph<undirected> g(n);
+    g.read_edges(m);
+    auto [v0, es] = euler_trail(g);
+    if(ssize(es) != m) {
+        cout << "No" << "\n";
+    } else {
+        cout << "Yes" << "\n";
+        cout << v0 << ' ';
+        for(auto e: es) {cout << g.edge(e).to << ' ';}
+        cout << "\n";
+        for(auto e: es) {cout << e / 2 << ' ';}
+        cout << "\n";
+    }
+}
+
+signed main() {
+    //freopen("input.txt", "r", stdin);
+    ios::sync_with_stdio(0);
+    cin.tie(0);
+    int t = 1;
+    cin >> t;
+    while(t--) {
+        solve();
+    }
+}