Func graph nit (#133)

* changes

* [auto-verifier] verify commit 1dcf679

* formatted now

* [auto-verifier] verify commit 9df472c

* update comment

* [auto-verifier] verify commit 58663a4

---------

Co-authored-by: GitHub <noreply@github.com>

Author: lrvideckis

.verify-helper/timestamps.remote.json

@@ -67,7 +67,7 @@
 "tests/library_checker_aizu_tests/handmade_tests/dsu_size.test.cpp": "2024-12-14 19:50:29 -0600",
 "tests/library_checker_aizu_tests/handmade_tests/edge_cd_small_trees.test.cpp": "2025-04-27 21:47:37 -0600",
 "tests/library_checker_aizu_tests/handmade_tests/fib_matrix_expo.test.cpp": "2024-12-14 19:50:29 -0600",
-"tests/library_checker_aizu_tests/handmade_tests/functional_graph.test.cpp": "2025-04-22 21:37:22 -0500",
+"tests/library_checker_aizu_tests/handmade_tests/functional_graph.test.cpp": "2025-05-31 11:14:03 -0600",
 "tests/library_checker_aizu_tests/handmade_tests/lca_ladder_forest.test.cpp": "2025-02-10 23:30:47 -0700",
 "tests/library_checker_aizu_tests/handmade_tests/manacher.test.cpp": "2024-12-14 19:50:29 -0600",
 "tests/library_checker_aizu_tests/handmade_tests/merge_st_and_wavelet.test.cpp": "2025-02-11 13:53:30 -0700",

library/graphs/functional_graph_processor.hpp

@@ -2,8 +2,8 @@
 //! https://github.com/Aeren1564/Algorithms/blob/master/Algorithm_Implementations_Cpp/Graph_Theory/Special_Graphs/functional_graph_processor.sublime-snippet
 //! @code
 //!   // 0 <= a[i] < n
-//!   auto [t, cycle] = func_graph(a);
-//!   auto [cyc_id, cyc_pos] = t[v].root_of;
+//!   auto [root_of, cycle, childs] = func_graph(a);
+//!   auto [cyc_id, cyc_pos] = root_of[v];
 //!   int root = cycle[cyc_id][cyc_pos];
 //!   bool is_on_cycle = (v == root);
 //! @endcode
@@ -12,13 +12,9 @@
 //! @time O(n)
 //! @space O(n)
 struct func_graph {
-  struct node {
-    pii root_of;
-    basic_string<int> childs;
-  };
-  vector<node> t;
-  vector<vi> cycle;
-  func_graph(const vi& a): t(sz(a)) {
+  vector<pii> root_of;
+  vector<basic_string<int>> cycle, childs;
+  func_graph(const vi& a): root_of(sz(a)), childs(sz(a)) {
     vi state(sz(a));
     rep(i, 0, sz(a)) {
       if (state[i] == 0) {
@@ -30,17 +26,16 @@ struct func_graph {
         if (state[u] == 1) {
           cycle.emplace_back();
           while (state[u] == 1) {
-            t[u].root_of = {
-              sz(cycle) - 1, sz(cycle.back())};
-            cycle.back().push_back(u);
+            root_of[u] = {sz(cycle) - 1, sz(cycle.back())};
+            cycle.back() += u;
             state[u] = 2;
             u = a[u];
           }
         }
         int v = i;
         while (state[v] == 1) {
-          t[v].root_of = t[u].root_of;
-          t[a[v]].childs += v;
+          root_of[v] = root_of[u];
+          childs[a[v]] += v;
           state[v] = 2;
           v = a[v];
         }

tests/library_checker_aizu_tests/handmade_tests/functional_graph.test.cpp

@@ -131,26 +131,30 @@ int main() {
     int n = rnd(1, 1000);
     vector<int> a(n);
     for (int i = 0; i < n; i++) a[i] = rnd(0, n - 1);
-    auto [t, cycle] = func_graph(a);
+    auto [root_of, cycle, childs] = func_graph(a);
     functional_graph_processor fgp(a);
-    assert(cycle == fgp.cycle);
+    assert(sz(cycle) == sz(fgp.cycle));
+    for (int i = 0; i < sz(cycle); i++) {
+      assert(sz(cycle[i]) == sz(fgp.cycle[i]));
+      for (int j = 0; j < sz(cycle[i]); j++)
+        assert(cycle[i][j] == fgp.cycle[i][j]);
+    }
     for (int i = 0; i < n; i++) {
       int root =
-        cycle[t[i].root_of.first][t[i].root_of.second];
+        cycle[root_of[i].first][root_of[i].second];
       assert(root == fgp.root_of[i]);
-      assert(equal(t[i].childs, fgp.abr[i]));
+      assert(equal(childs[i], fgp.abr[i]));
       assert((root == i) == (fgp.cycle_id[i] != -1));
       if (root == i) {
-        assert(t[i].root_of.first == fgp.cycle_id[i]);
-        assert(t[i].root_of.second == fgp.cycle_pos[i]);
-        int cyc_len = ssize(cycle[t[i].root_of.first]);
-        assert(
-          cycle[t[i].root_of.first]
-               [(t[i].root_of.second + 1) % cyc_len] ==
+        assert(root_of[i].first == fgp.cycle_id[i]);
+        assert(root_of[i].second == fgp.cycle_pos[i]);
+        int cyc_len = ssize(cycle[root_of[i].first]);
+        assert(cycle[root_of[i].first]
+                    [(root_of[i].second + 1) % cyc_len] ==
           a[i]);
         assert(fgp.cycle_prev[i] ==
-          cycle[t[i].root_of.first]
-               [(t[i].root_of.second - 1 + cyc_len) %
+          cycle[root_of[i].first]
+               [(root_of[i].second - 1 + cyc_len) %
                  cyc_len]);
       } else {
         assert(fgp.cycle_prev[i] == -1);