Use stack_union and int in graphs instead of size_t

Author: adamant-pwn

cp-algo/data_structures/stack_union.hpp

@@ -0,0 +1,27 @@
+#ifndef CP_ALGO_DATA_STRUCTURES_STACK_UNION_HPP
+#define CP_ALGO_DATA_STRUCTURES_STACK_UNION_HPP
+#include <cstddef>
+#include <vector>
+namespace cp_algo::data_structures {
+    template<class datatype>
+    struct stack_union {
+        stack_union(size_t n): n(n), head(n), next(1), data(1) {}
+
+        void push(size_t v, datatype const& vdata) {
+            next.push_back(head[v]);
+            head[v] = size(next) - 1;
+            data.push_back(vdata);
+        }
+        template<typename... Args>
+        void emplace(size_t v, Args&&... vdata) {
+            next.push_back(head[v]);
+            head[v] = size(next) - 1;
+            data.emplace_back(std::forward<Args...>(vdata...));
+        }
+
+        size_t n;
+        std::vector<size_t> head, next;
+        std::vector<datatype> data;
+    };
+}
+#endif // CP_ALGO_DATA_STRUCTURES_STACK_UNION_HPP

cp-algo/graph/base.hpp

@@ -1,42 +1,44 @@
 #ifndef CP_ALGO_GRAPH_BASE_HPP
 #define CP_ALGO_GRAPH_BASE_HPP
+#include "../data_structures/stack_union.hpp"
 #include <iostream>
 #include <ranges>
 #include <vector>
 namespace cp_algo::graph {
     enum type {directed = 0, undirected = 1};
     template<type undirected>
     struct graph {
-        graph(size_t n, size_t v0 = 0): n(n), v0(v0), adj(n) {}
+        graph(int n, int v0 = 0): n(n), v0(v0), adj(n) {}
 
-        void add_edge(size_t u, size_t v) {
-            adj[u - v0].push_back(size(to));
+        void add_edge(int u, int v) {
+            adj.push(u - v0, size(to));
             to.push_back(v - v0);
             if constexpr (undirected) {
-                adj[v - v0].push_back(size(to));
+                adj.push(v - v0, size(to));
             }
             to.push_back(u - v0);
         }
-        void read_edges(size_t m) {
-            for(size_t i = 0; i < m; i++) {
+        void read_edges(int m) {
+            for(int i = 0; i < m; i++) {
                 int u, v;
                 std::cin >> u >> v;
                 add_edge(u, v);
             }
         }
-        auto adjacent_generator(size_t v) const {
-            return [&adj = adj[v], idx = 0]() mutable {
-                return idx < ssize(adj) ? adj[idx++] : -1;
+        auto adjacent_generator(int v) const {
+            return [&adj = adj, v = adj.head[v]]() mutable {
+                int e = v ? adj.data[v] : -1;
+                v = adj.next[v];
+                return e;
             };
         }
         auto nodes_view() const {
-            return std::views::iota((size_t)0, n);
+            return std::views::iota(0, n);
         }
 
-        size_t n;
-        size_t v0;
-        std::vector<size_t> to;
-        std::vector<std::vector<size_t>> adj;
+        int n, v0;
+        std::vector<int> to;
+        data_structures::stack_union<int> adj;
     };
 }
 #endif // CP_ALGO_GRAPH_BASE_HPP

cp-algo/graph/cycle.hpp

@@ -4,13 +4,13 @@
 #include <algorithm>
 #include <vector>
 namespace cp_algo::graph {
-    std::vector<size_t> find_cycle(auto const& g) {
+    std::vector<int> find_cycle(auto const& g) {
         std::vector<char> state(g.n);
-        std::vector<size_t> cycle;
-        auto dfs = [&](auto self, size_t v, size_t pe) -> bool {
+        std::vector<int> cycle;
+        auto dfs = [&](auto &&self, int v, int pe) -> bool {
             state[v] = 1;
             auto gen = g.adjacent_generator(v);
-            for(size_t e = gen(); ~e; e = gen()) {
+            for(int e = gen(); ~e; e = gen()) {
                 if(e / 2 != pe / 2) {
                     auto u = g.to[e];
                     if(state[u] == 0) {
@@ -29,8 +29,8 @@ namespace cp_algo::graph {
             state[v] = 2;
             return false;
         };
-        for(size_t i: g.nodes_view()) {
-            if(!state[i] && dfs(dfs, i, -1)) {
+        for(int i: g.nodes_view()) {
+            if(!state[i] && dfs(dfs, i, -2)) {
                 break;
             }
         }

verify/graph/cycle.test.cpp renamed to verify/graph/cycle_directed.test.cpp

@@ -1,7 +1,7 @@
 // @brief Cycle Detection (Directed)
 #define PROBLEM "https://judge.yosupo.jp/problem/cycle_detection"
 #pragma GCC optimize("Ofast,unroll-loops")
-//#pragma GCC target("tune=native")
+#pragma GCC target("tune=native")
 #include "cp-algo/graph/cycle.hpp"
 #include <bits/stdc++.h>
 

verify/graph/cycle_undirected.test.cpp

@@ -1,7 +1,7 @@
 // @brief Cycle Detection (Undirected)
 #define PROBLEM "https://judge.yosupo.jp/problem/cycle_detection_undirected"
 #pragma GCC optimize("Ofast,unroll-loops")
-//#pragma GCC target("tune=native")
+#pragma GCC target("tune=native")
 #include "cp-algo/graph/cycle.hpp"
 #include <bits/stdc++.h>