Generic dfs in cycle detection

Author: adamant-pwn

cp-algo/graph/cycle.hpp

@@ -1,46 +1,38 @@
 #ifndef CP_ALGO_GRAPH_CYCLE_HPP
 #define CP_ALGO_GRAPH_CYCLE_HPP
+#include "dfs.hpp"
 #include "base.hpp"
-#include <algorithm>
+#include <deque>
 namespace cp_algo::graph {
     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;
+    struct cycle_context: dfs_context<graph> {
+        using base = dfs_context<graph>;
+        using base::base;
+        std::deque<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;
-                        }
-                        return true;
-                    }
-                } else if(state[u] == visiting) {
-                    cycle = {e};
-                    return true;
-                }
+        int v0;
+        
+        void on_return_from_child(node_index v, edge_index e) {
+            if (!empty(cycle) && !closed) {
+                cycle.push_front(e);
+                closed |= v == v0;
             }
-            state[v] = visited;
-            return false;
-        };
-        for(node_index i: g.nodes()) {
-            if(state[i] == unvisited && dfs(i)) {
-                break;
+        }
+        
+        void on_back_edge(node_index v, edge_index e) {
+            if (empty(cycle)) {
+                v0 = base::g->edge(e).to;
+                base::done = true;
+                closed = v == v0;
+                cycle.push_front(e);
             }
         }
-        std::ranges::reverse(cycle);
-        return cycle;
+    };
+    
+    template<graph_type graph>
+    std::deque<edge_index> find_cycle(graph const& g) {
+        auto context = dfs<cycle_context>(g);
+        return context.cycle;
     }
 }
 #endif // CP_ALGO_GRAPH_CYCLE_HPP

cp-algo/graph/dfs.hpp

@@ -10,31 +10,32 @@ namespace cp_algo::graph {
     struct dfs_context {
         big_vector<node_state> state;
         graph const* g;
+        bool done = false;  // Set to true to stop DFS early
 
         dfs_context(graph const& g): state(g.n()), g(&g) {}
 
         // Called when first entering a node
         void on_enter(node_index) {}
 
         // Called when discovering a tree edge (v->u is a tree edge, u is unvisited)
-        void on_tree_edge(node_index, node_index, edge_index) {}
+        void on_tree_edge(node_index, edge_index) {}
 
         // Called after returning from a child via tree edge
-        void on_return_from_child(node_index, node_index, edge_index) {}
+        void on_return_from_child(node_index, edge_index) {}
 
         // Called when encountering a back edge (v->u, u is visiting)
-        void on_back_edge(node_index, node_index, edge_index) {}
+        void on_back_edge(node_index, edge_index) {}
 
         // Called when encountering a forward/cross edge (v->u, u is visited)
-        void on_forward_cross_edge(node_index, node_index, edge_index) {}
+        void on_forward_cross_edge(node_index, edge_index) {}
 
         // Called when exiting a node (all edges processed)
         void on_exit(node_index) {}
     };
 
     template<template<typename> class Context, graph_type graph>
-    Context<graph>& dfs(Context<graph>& context) {
-        graph const& g = *context.g;
+    Context<graph> dfs(graph const& g) {
+        Context<graph> context(g);
         auto const& adj = g.incidence_lists();
         struct frame {
             node_index v;
@@ -48,6 +49,7 @@ namespace cp_algo::graph {
         std::stack<frame> dfs_stack;
 
         for (auto root: g.nodes()) {
+            if (context.done) break;
             if (context.state[root] != unvisited) continue;
 
             if constexpr (undirected_graph_type<graph>) {
@@ -56,27 +58,28 @@ namespace cp_algo::graph {
                 dfs_stack.push({root, {}, 0, frame::INIT});
             }
 
-            while (!dfs_stack.empty()) {
+            while (!empty(dfs_stack)) {
                 auto& f = dfs_stack.top();
 
                 if (f.state == frame::INIT) {
                     context.state[f.v] = visiting;
                     context.on_enter(f.v);
                     f.sv = adj.head[f.v];
                     f.state = frame::PROCESS_EDGES;
+                    continue;
                 }
 
                 if (f.state == frame::HANDLE_CHILD) {
                     auto e = adj.data[f.sv];
                     f.sv = adj.next[f.sv];
-                    node_index u = g.edge(e).to;
-                    context.on_return_from_child(f.v, u, e);
+                    context.on_return_from_child(f.v, e);
                     f.state = frame::PROCESS_EDGES;
+                    continue;
                 }
-                
+
                 // PROCESS_EDGES
                 bool found_child = false;
-                while (f.sv != 0) {
+                while (f.sv != 0 && !context.done) {
                     auto e = adj.data[f.sv];
 
                     if constexpr (undirected_graph_type<graph>) {
@@ -88,7 +91,7 @@ namespace cp_algo::graph {
 
                     node_index u = g.edge(e).to;
                     if (context.state[u] == unvisited) {
-                        context.on_tree_edge(f.v, u, e);
+                        context.on_tree_edge(f.v, e);
                         f.state = frame::HANDLE_CHILD;
                         if constexpr (undirected_graph_type<graph>) {
                             dfs_stack.push({u, e, 0, frame::INIT});
@@ -98,9 +101,9 @@ namespace cp_algo::graph {
                         found_child = true;
                         break;
                     } else if (context.state[u] == visiting) {
-                        context.on_back_edge(f.v, u, e);
+                        context.on_back_edge(f.v, e);
                     } else if (context.state[u] == visited) {
-                        context.on_forward_cross_edge(f.v, u, e);
+                        context.on_forward_cross_edge(f.v, e);
                     }
                     f.sv = adj.next[f.sv];
                 }

cp-algo/graph/tarjan.hpp

@@ -9,12 +9,13 @@
 namespace cp_algo::graph {
     template<graph_type graph>
     struct tarjan_context: dfs_context<graph> {
+        using base = dfs_context<graph>;
         big_vector<int> tin, low;
         std::stack<int> stack;
         int timer;
         structures::csr<node_index> components;
 
-        tarjan_context(graph const& g): dfs_context<graph>(g),
+        tarjan_context(graph const& g): base(g),
             tin(g.n()), low(g.n()), timer(0) {
             components.reserve_data(g.n());
         }
@@ -24,15 +25,18 @@ namespace cp_algo::graph {
             stack.push(v);
         }
 
-        void on_return_from_child(node_index v, node_index u, edge_index) {
+        void on_return_from_child(node_index v, edge_index e) {
+            node_index u = base::g->edge(e).to;
             low[v] = std::min(low[v], low[u]);
         }
 
-        void on_back_edge(node_index v, node_index u, edge_index) {
+        void on_back_edge(node_index v, edge_index e) {
+            node_index u = base::g->edge(e).to;
             low[v] = std::min(low[v], tin[u]);
         }
 
-        void on_forward_cross_edge(node_index v, node_index u, edge_index) {
+        void on_forward_cross_edge(node_index v, edge_index e) {
+            node_index u = base::g->edge(e).to;
             low[v] = std::min(low[v], tin[u]);
         }
 
@@ -44,17 +48,11 @@ namespace cp_algo::graph {
             do {
                 u = stack.top();
                 stack.pop();
-                this->state[u] = blocked;
+                base::state[u] = blocked;
                 components.push(u);
             } while(u != v);
         }
     };
-    
-    template<template<typename> class Context, graph_type graph>
-    auto tarjan(graph const& g) {
-        Context<graph> context(g);
-        return dfs(context).components;
-    }
     template<graph_type graph>
     struct exit_context: tarjan_context<graph> {
         using tarjan_context<graph>::tarjan_context;
@@ -69,22 +67,23 @@ namespace cp_algo::graph {
     // returns components in reverse topological order
     template<digraph_type graph>
     auto strongly_connected_components(graph const& g) {
-        return tarjan<exit_context>(g);
+        return dfs<exit_context>(g).components;
     }
 
     // Tarjan's algorithm for Two-Edge-Connected Components
     template<undirected_graph_type graph>
     auto two_edge_connected_components(graph const& g) {
-        return tarjan<exit_context>(g);
+        return dfs<exit_context>(g).components;
     }
 
     template<undirected_graph_type graph>
     struct bcc_context: tarjan_context<graph> {
         using base = tarjan_context<graph>;
         using base::base;
 
-        void on_return_from_child(node_index v, node_index u, edge_index e) {
-            base::on_return_from_child(v, u, e);
+        void on_return_from_child(node_index v, edge_index e) {
+            base::on_return_from_child(v, e);
+            node_index u = base::g->edge(e).to;
             if (base::low[u] >= base::tin[v]) {
                 base::collect(u);
                 base::components.push(v);
@@ -99,7 +98,7 @@ namespace cp_algo::graph {
     // Tarjan's algorithm for Biconnected Components (vertex-biconnected)
     template<undirected_graph_type graph>
     auto biconnected_components(graph const& g) {
-        return tarjan<bcc_context>(g);
+        return dfs<bcc_context>(g).components;
     }
 }
 #endif // CP_ALGO_GRAPH_TARJAN_HPP

verify/graph/cycle_undirected.test.cpp

@@ -16,10 +16,11 @@ void solve() {
     if(empty(res)) {
         cout << -1 << "\n";
     } else {
-        ranges::reverse(res);
         cout << size(res) << "\n";
+        ranges::rotate(res, prev(end(res)));
         for(auto it: res) {cout << g.edge(it).to << ' ';}
         cout << "\n";
+        ranges::rotate(res, next(begin(res)));
         for(auto it: res) {cout << graph<>::canonical_idx(it) << ' ';}
         cout << "\n";
     }