Split Tarjan context

Author: adamant-pwn

cp-algo/graph/dfs_time.hpp

@@ -0,0 +1,62 @@
+#ifndef CP_ALGO_GRAPH_DFS_TIME_HPP
+#define CP_ALGO_GRAPH_DFS_TIME_HPP
+#include "dfs.hpp"
+#include "base.hpp"
+namespace cp_algo::graph {
+    // Context that maintains discovery time (tin)
+    template<graph_type graph>
+    struct dfs_time_context: dfs_context<graph> {
+        using base = dfs_context<graph>;
+        big_vector<int> tin;
+        int timer;
+        
+        dfs_time_context(graph const& g): base(g), tin(g.n()), timer(0) {}
+        
+        void on_enter(node_index v) {
+            tin[v] = timer++;
+        }
+    };
+    
+    // Context that maintains both discovery time (tin) and finish time (tout)
+    template<graph_type graph>
+    struct dfs_time_range_context: dfs_time_context<graph> {
+        using base = dfs_time_context<graph>;
+        big_vector<int> tout;
+        
+        dfs_time_range_context(graph const& g): base(g), tout(g.n()) {}
+        
+        void on_exit(node_index v) {
+            tout[v] = base::timer;
+        }
+    };
+    
+    // Context that maintains tin and low (for Tarjan-like algorithms)
+    template<graph_type graph>
+    struct dfs_low_context: dfs_time_context<graph> {
+        using base = dfs_time_context<graph>;
+        big_vector<int> low;
+        
+        dfs_low_context(graph const& g): base(g), low(g.n()) {}
+        
+        void on_enter(node_index v) {
+            base::on_enter(v);
+            low[v] = base::tin[v];
+        }
+        
+        void on_return_from_child(node_index v, edge_index e) {
+            node_index u = base::g->edge(e).traverse(v);
+            low[v] = std::min(low[v], low[u]);
+        }
+        
+        void on_back_edge(node_index v, edge_index e) {
+            node_index u = base::g->edge(e).traverse(v);
+            low[v] = std::min(low[v], base::tin[u]);
+        }
+        
+        void on_forward_cross_edge(node_index v, edge_index e) {
+            node_index u = base::g->edge(e).traverse(v);
+            low[v] = std::min(low[v], base::tin[u]);
+        }
+    };
+}
+#endif // CP_ALGO_GRAPH_DFS_TIME_HPP

cp-algo/graph/tarjan.hpp

@@ -1,47 +1,28 @@
 #ifndef CP_ALGO_GRAPH_TARJAN_HPP
 #define CP_ALGO_GRAPH_TARJAN_HPP
-#include "dfs.hpp"
+#include "dfs_time.hpp"
 #include "base.hpp"
 #include "../structures/csr.hpp"
 #include <algorithm>
 #include <cassert>
 #include <stack>
 namespace cp_algo::graph {
+    // Add stack and components collection
     template<graph_type graph>
-    struct tarjan_context: dfs_context<graph> {
-        using base = dfs_context<graph>;
-        big_vector<int> tin, low;
+    struct tarjan_context: dfs_low_context<graph> {
+        using base = dfs_low_context<graph>;
         std::stack<int> stack;
-        int timer;
         structures::csr<node_index> components;
 
-        tarjan_context(graph const& g): base(g),
-            tin(g.n()), low(g.n()), timer(0) {
+        tarjan_context(graph const& g): base(g) {
             components.reserve_data(g.n());
         }
 
         void on_enter(node_index v) {
-            tin[v] = low[v] = timer++;
+            base::on_enter(v);
             stack.push(v);
         }
 
-        void on_return_from_child(node_index v, edge_index e) {
-            node_index u = base::g->edge(e).traverse(v);
-            low[v] = std::min(low[v], low[u]);
-        }
-
-        void on_back_edge(node_index v, edge_index e) {
-            node_index u = base::g->edge(e).traverse(v);
-            low[v] = std::min(low[v], tin[u]);
-        }
-
-        void on_forward_cross_edge(node_index v, edge_index e) {
-            node_index u = base::g->edge(e).traverse(v);
-            low[v] = std::min(low[v], tin[u]);
-        }
-
-        void on_tree_edge_processed(node_index, node_index, edge_index) {}
-
         void collect(node_index v) {
             components.new_row();
             node_index u;