decrease

Author: lrvideckis

tests/library_checker_aizu_tests/handmade_tests/functional_graph.test.cpp

@@ -9,7 +9,7 @@ struct functional_graph_processor {
     init(sz(next));
     build(next);
   }
-  template<class Graph_t>
+  template <class Graph_t>
   functional_graph_processor(const Graph_t &g) {
     init(g.n);
     build(g);
@@ -101,36 +101,36 @@ struct functional_graph_processor {
   }
   int n;
   vector<vector<int>> cycle;
-  vector<int> cycle_id; // id of the cycle it belongs to,
-                        // -1 if not part of one
-  vector<int> cycle_pos; // position in its cycle, -1 if
-                         // not part of one
-  vector<int> cycle_prev; // previous vertex in its cycle,
-                          // -1 if not part of one
-  vector<int> component_size; // size of its weakly
-                              // connected component
-  vector<int> root_of; // first reachable node in a cycle
-  vector<int> depth; // distance to its root
+  vector<int> cycle_id;  // id of the cycle it belongs to,
+                         // -1 if not part of one
+  vector<int> cycle_pos;  // position in its cycle, -1 if
+                          // not part of one
+  vector<int> cycle_prev;  // previous vertex in its cycle,
+                           // -1 if not part of one
+  vector<int> component_size;  // size of its weakly
+                               // connected component
+  vector<int> root_of;  // first reachable node in a cycle
+  vector<int> depth;  // distance to its root
   vector<vector<int>>
-    abr; // forest of arborescences of reversed edges not
-         // on the cycles
-  vector<int> order; // dfs order of abr
-  vector<int> pos; // pos in the dfs order
-  vector<int> end; // [pos[u], end[u]) denotes the subtree
-  vector<int> size; // size of the subtree in abr
+      abr;  // forest of arborescences of reversed edges not
+            // on the cycles
+  vector<int> order;  // dfs order of abr
+  vector<int> pos;  // pos in the dfs order
+  vector<int> end;  // [pos[u], end[u]) denotes the subtree
+  vector<int> size;  // size of the subtree in abr
 };
 int main() {
   cin.tie(0)->sync_with_stdio(0);
-  for (int num_tests = 1000; num_tests--;) {
-    int n = rnd(1, 10000);
+  for (int num_tests = 100; num_tests--;) {
+    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);
     functional_graph_processor fgp(a);
     assert(cycle == fgp.cycle);
     for (int i = 0; i < n; i++) {
       int root =
-        cycle[t[i].root_of.first][t[i].root_of.second];
+          cycle[t[i].root_of.first][t[i].root_of.second];
       assert(root == fgp.root_of[i]);
       assert(t[i].childs == fgp.abr[i]);
       assert((root == i) == (fgp.cycle_id[i] != -1));
@@ -139,13 +139,13 @@ int main() {
         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] ==
-          a[i]);
+            cycle[t[i].root_of.first]
+                 [(t[i].root_of.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) %
-                 cyc_len]);
+               cycle[t[i].root_of.first]
+                    [(t[i].root_of.second - 1 + cyc_len) %
+                     cyc_len]);
       } else {
         assert(fgp.cycle_prev[i] == -1);
       }