format

lrvideckis · lrvideckis · commit cc684ec2ab27 · 2024-12-15T12:37:34.000-06:00
diff --git a/library/graphs/strongly_connected_components/offline_incremental_scc.hpp b/library/graphs/strongly_connected_components/offline_incremental_scc.hpp
@@ -11,13 +11,13 @@
 //! @time O((n + m) log m)
 //! @space O(n + m)
 vi offline_incremental_scc(vector<array<int, 2>> eds,
-                           int n) {
+  int n) {
   int m = sz(eds);
   vi ids(n, -1), joins(m, m), idx(m), vs(n), scc_id;
   iota(all(idx), 0);
   vector<basic_string<int>> adj;
   auto divide_and_conquer = [&](auto&& self, auto el,
-                                auto er, int tl, int tr) {
+                              auto er, int tl, int tr) {
     adj.clear();
     int mid = midpoint(tl, tr);
     for (auto it = el; it != er; it++) {
diff --git a/library/math/count_paths/count_paths_triangle.hpp b/library/math/count_paths/count_paths_triangle.hpp
@@ -6,7 +6,8 @@
 vl divide_and_conquer(vl h, vl bottom) {
   {
     int start =
-        ranges::find_if(h, [](ll x) { return x; }) - begin(h);
+      ranges::find_if(h, [](ll x) { return x; }) -
+      begin(h);
     h.erase(begin(h), begin(h) + start);
     bottom.erase(begin(bottom), begin(bottom) + start);
   }
@@ -15,10 +16,10 @@ vl divide_and_conquer(vl h, vl bottom) {
   if (n == 1) return vl(h[0], bottom[0]);
   int mid = n / 2;
   auto rect_left =
-      divide_and_conquer(vl(begin(h), begin(h) + mid),
-                         vl(begin(bottom), begin(bottom) + mid));
+    divide_and_conquer(vl(begin(h), begin(h) + mid),
+      vl(begin(bottom), begin(bottom) + mid));
   auto [rect_right, rect_top] =
-      get_right_and_top(rect_left, vl(mid + all(bottom)));
+    get_right_and_top(rect_left, vl(mid + all(bottom)));
   vl h_right(mid + all(h));
   for (ll& hh : h_right) hh -= h[mid - 1];
   auto upper_right = divide_and_conquer(h_right, rect_top);
diff --git a/library/trees/centroid_decomp_uncommon/count_paths_per_length.hpp b/library/trees/centroid_decomp_uncommon/count_paths_per_length.hpp
@@ -10,33 +10,35 @@
 vector<ll> count_paths_per_length(const vector<vi>& adj) {
   vector<ll> num_paths(sz(adj));
   centroid(adj,
-           [&](const vector<vi>& cd_adj, int cent, int) {
-             vector<vector<double>> child_depths;
-             for (int v : cd_adj[cent]) {
-               child_depths.emplace_back(1, 0.0);
-               for (queue<pii> q({{v, cent}}); !empty(q);) {
-                 child_depths.back().push_back(sz(q));
-                 queue<pii> new_q;
-                 while (!empty(q)) {
-                   auto [u, p] = q.front();
-                   q.pop();
-                   for (int w : cd_adj[u]) {
-                     if (w == p) continue;
-                     new_q.emplace(w, u);
-                   }
-                 }
-                 swap(q, new_q);
-               }
-             }
-             ranges::sort(child_depths, {}, [&](auto& x) { return sz(x); });
-             vector total_depth(1, 1.0);
-             for (auto& cnt_depth : child_depths) {
-               auto prod = conv(total_depth, cnt_depth);
-               rep(i, 1, sz(prod)) num_paths[i] += llround(prod[i]);
-               total_depth.resize(sz(cnt_depth));
-               rep(i, 1, sz(cnt_depth)) total_depth[i] +=
-                   cnt_depth[i];
-             }
-           });
+    [&](const vector<vi>& cd_adj, int cent, int) {
+      vector<vector<double>> child_depths;
+      for (int v : cd_adj[cent]) {
+        child_depths.emplace_back(1, 0.0);
+        for (queue<pii> q({{v, cent}}); !empty(q);) {
+          child_depths.back().push_back(sz(q));
+          queue<pii> new_q;
+          while (!empty(q)) {
+            auto [u, p] = q.front();
+            q.pop();
+            for (int w : cd_adj[u]) {
+              if (w == p) continue;
+              new_q.emplace(w, u);
+            }
+          }
+          swap(q, new_q);
+        }
+      }
+      ranges::sort(child_depths, {},
+        [&](auto& x) { return sz(x); });
+      vector total_depth(1, 1.0);
+      for (auto& cnt_depth : child_depths) {
+        auto prod = conv(total_depth, cnt_depth);
+        rep(i, 1, sz(prod)) num_paths[i] +=
+          llround(prod[i]);
+        total_depth.resize(sz(cnt_depth));
+        rep(i, 1, sz(cnt_depth)) total_depth[i] +=
+          cnt_depth[i];
+      }
+    });
   return num_paths;
 }
diff --git a/library/trees/subtree_isomorphism.hpp b/library/trees/subtree_isomorphism.hpp
@@ -22,7 +22,9 @@ auto subtree_iso(const auto& adj) {
     for (int u : adj[v])
       if (u != p) ch_ids.push_back(self(self, u, v));
     ranges::sort(ch_ids);
-    return iso_id[v] = hashes.try_emplace(ch_ids, sz(hashes)).first->second;
+    return iso_id[v] =
+             hashes.try_emplace(ch_ids, sz(hashes))
+               .first->second;
   };
   rep(i, 0, sz(adj)) if (iso_id[i] == -1) dfs(dfs, i, i);
   return pair{sz(hashes), iso_id};
diff --git a/tests/library_checker_aizu_tests/cd_asserts.hpp b/tests/library_checker_aizu_tests/cd_asserts.hpp
@@ -4,26 +4,26 @@ void cd_asserts(const vector<vector<int>>& adj) {
   vector<int> decomp_size(sz(adj), -1);
   vector<int> naive_par_decomp(sz(adj), -1);
   centroid(adj,
-           [&](const vector<vector<int>>& cd_adj, int cent,
-               int par_cent) -> void {
-             assert(naive_par_decomp[cent] == par_cent);
-             assert(decomp_size[cent] == -1);
-             auto dfs = [&](auto&& self, int u, int p) -> int {
-               naive_par_decomp[u] = cent;
-               int sub_size = 1;
-               for (int v : cd_adj[u])
-                 if (v != p) sub_size += self(self, v, u);
-               return sub_size;
-             };
-             decomp_size[cent] = dfs(dfs, cent, -1);
-             if (par_cent != -1)
-               assert(1 <= decomp_size[cent] &&
-                      2 * decomp_size[cent] <= decomp_size[par_cent]);
-             for (int u : cd_adj[cent]) {
-               int sz_subtree = dfs(dfs, u, cent);
-               assert(1 <= sz_subtree &&
-                      2 * sz_subtree <= decomp_size[cent]);
-             }
-           });
+    [&](const vector<vector<int>>& cd_adj, int cent,
+      int par_cent) -> void {
+      assert(naive_par_decomp[cent] == par_cent);
+      assert(decomp_size[cent] == -1);
+      auto dfs = [&](auto&& self, int u, int p) -> int {
+        naive_par_decomp[u] = cent;
+        int sub_size = 1;
+        for (int v : cd_adj[u])
+          if (v != p) sub_size += self(self, v, u);
+        return sub_size;
+      };
+      decomp_size[cent] = dfs(dfs, cent, -1);
+      if (par_cent != -1)
+        assert(1 <= decomp_size[cent] &&
+          2 * decomp_size[cent] <= decomp_size[par_cent]);
+      for (int u : cd_adj[cent]) {
+        int sz_subtree = dfs(dfs, u, cent);
+        assert(1 <= sz_subtree &&
+          2 * sz_subtree <= decomp_size[cent]);
+      }
+    });
   rep(i, 0, sz(adj)) assert(decomp_size[i] >= 1);
 }
diff --git a/tests/library_checker_aizu_tests/data_structures/range_parallel_dsu.test.cpp b/tests/library_checker_aizu_tests/data_structures/range_parallel_dsu.test.cpp
@@ -30,7 +30,8 @@ int main() {
     dsu.join(a, b, k, f);
     queries.push_back({a, b, k});
     cout << ans.x << '\n';
-    if (qq == 0 || qq == 1 || qq == 10 || qq == 1000 || qq == 100'000 || qq == q - 1) {
+    if (qq == 0 || qq == 1 || qq == 10 || qq == 1000 ||
+      qq == 100'000 || qq == q - 1) {
       auto uf = get_rp_dsu(queries, n);
       vector<mint> sums(n);
       mint offline_ans = 0;
diff --git a/tests/library_checker_aizu_tests/data_structures/rmq_linear.test.cpp b/tests/library_checker_aizu_tests/data_structures/rmq_linear.test.cpp
@@ -17,14 +17,20 @@ int main() {
     int l, r;
     cin >> l >> r;
     int idx_right_min = rmq_less.query_idx(l, r - 1);
-    assert(idx_right_min + 1 == r || rmq_less.query(idx_right_min + 1, r - 1) > a[idx_right_min]);
+    assert(idx_right_min + 1 == r ||
+      rmq_less.query(idx_right_min + 1, r - 1) >
+        a[idx_right_min]);
     assert(l <= idx_right_min && idx_right_min < r);
     assert(rmq_less.query(l, r - 1) == a[idx_right_min]);
-    assert(idx_right_min == rmq_greater.query_idx(l, r - 1));
+    assert(
+      idx_right_min == rmq_greater.query_idx(l, r - 1));
     int idx_left_min = rmq_less_equal.query_idx(l, r - 1);
-    assert(l == idx_left_min || rmq_less_equal.query(l, idx_left_min - 1) > a[idx_left_min]);
+    assert(l == idx_left_min ||
+      rmq_less_equal.query(l, idx_left_min - 1) >
+        a[idx_left_min]);
     assert(l <= idx_left_min && idx_left_min < r);
-    assert(idx_left_min == rmq_greater_equal.query_idx(l, r - 1));
+    assert(idx_left_min ==
+      rmq_greater_equal.query_idx(l, r - 1));
     assert(a[idx_right_min] == a[idx_left_min]);
     assert(idx_left_min <= idx_right_min);
     cout << a[idx_right_min] << '\n';
diff --git a/tests/library_checker_aizu_tests/graphs/offline_incremental_scc.test.cpp b/tests/library_checker_aizu_tests/graphs/offline_incremental_scc.test.cpp
@@ -18,7 +18,8 @@ int main() {
     assert((eds[t][0] == eds[t][1]) == (joins[t] == -1));
   vector<int> order(m);
   iota(all(order), 0);
-  ranges::sort(all(order), {}, [&](int i) { return joins[i]; });
+  ranges::sort(all(order), {},
+    [&](int i) { return joins[i]; });
   UF uf(n);
   mint sum = 0;
   for (int t = 0, it = 0; t < m; t++) {
diff --git a/tests/library_checker_aizu_tests/handmade_tests/count_paths_forest.test.cpp b/tests/library_checker_aizu_tests/handmade_tests/count_paths_forest.test.cpp
@@ -8,7 +8,7 @@
 #include "../../../library/trees/centroid_decomp_uncommon/count_paths_per_length.hpp"
 #include "../cd_asserts.hpp"
 vector<vector<ll>> naive(const vector<vector<int>>& adj,
-                         dsu_restorable& dsu) {
+  dsu_restorable& dsu) {
   tree_lift tl(adj);
   int n = sz(adj);
   vector<vector<ll>> cnts_naive(n + 1, vector<ll>(n, 0));
@@ -42,13 +42,13 @@ int main() {
     vector<vector<ll>> cnts_naive = naive(adj, dsu);
     for (int k = 1; k <= n; k++)
       assert(
-          count_paths_per_node(adj, k) == cnts_naive[k]);
+        count_paths_per_node(adj, k) == cnts_naive[k]);
     vector<ll> num_paths_len = count_paths_per_length(adj);
     for (int k = 1; k < n; k++) {
       vector<ll> count_paths =
-          count_paths_per_node(adj, k);
+        count_paths_per_node(adj, k);
       ll total_paths = accumulate(begin(count_paths),
-                                  end(count_paths), 0LL);
+        end(count_paths), 0LL);
       assert(total_paths % (k + 1) == 0);
       total_paths /= k + 1;
       assert(num_paths_len[k] == total_paths);
diff --git a/tests/library_checker_aizu_tests/handmade_tests/edge_cd_small_trees.test.cpp b/tests/library_checker_aizu_tests/handmade_tests/edge_cd_small_trees.test.cpp
@@ -9,21 +9,21 @@ int main() {
   {
     vector<vector<int>> adj;
     edge_cd(adj,
-            [&](const vector<vector<int>>&, int, int) -> void {
-              assert(false);
-            });
+      [&](const vector<vector<int>>&, int, int) -> void {
+        assert(false);
+      });
   }
   {
     vector<vector<int>> adj(1);
     edge_cd(adj,
-            [&](const vector<vector<int>>&, int, int) -> void {
-              assert(false);
-            });
+      [&](const vector<vector<int>>&, int, int) -> void {
+        assert(false);
+      });
   }
   for (int n = 2; n <= 7; n++) {
     int num_codes = mpow(n, n - 2).x;
     vector<vector<int>> pruf_codes(num_codes,
-                                   vector<int>(n - 2));
+      vector<int>(n - 2));
     for (int i = 0; i < num_codes; i++) {
       int val = i;
       for (int j = 0; j < n - 2; j++) {
diff --git a/tests/library_checker_aizu_tests/handmade_tests/functional_graph.test.cpp b/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,23 +101,23 @@ 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);
@@ -130,7 +130,7 @@ int main() {
     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);
       }
diff --git a/tests/library_checker_aizu_tests/mono_st_asserts.hpp b/tests/library_checker_aizu_tests/mono_st_asserts.hpp
@@ -5,7 +5,7 @@
 #include "../../library/data_structures/uncommon/linear_rmq.hpp"
 tuple<int, vector<vector<int>>, vector<int>>
 min_cartesian_tree(const vector<int>& a,
-                   const vector<int>& l, const vector<int>& r) {
+  const vector<int>& l, const vector<int>& r) {
   int n = sz(a);
   assert(sz(l) == n && sz(r) == n);
   auto is_node = [&](int i) -> bool {
@@ -23,7 +23,7 @@ min_cartesian_tree(const vector<int>& a,
       root = i;
     } else if (is_node(i)) {
       bool le_par =
-          (l[i] >= 0 && (r[i] == n || a[l[i]] > a[r[i]]));
+        (l[i] >= 0 && (r[i] == n || a[l[i]] > a[r[i]]));
       adj[to_min[le_par ? l[i] : r[i]]].push_back(i);
     }
   }
@@ -41,11 +41,11 @@ void mono_st_asserts(const vector<int>& a) {
          p = cart_binary_tree(l);
     {
       vector old_way_ri = mono_st(vi{rbegin(a), rend(a)},
-                                  [&](int x, int y) { return !cmp(y, x); });
+        [&](int x, int y) { return !cmp(y, x); });
       reverse(begin(old_way_ri), end(old_way_ri));
       transform(begin(old_way_ri), end(old_way_ri),
-                begin(old_way_ri),
-                [&](int i) { return sz(a) - i - 1; });
+        begin(old_way_ri),
+        [&](int i) { return sz(a) - i - 1; });
       assert(r == old_way_ri);
     }
     int iterations = 0;
diff --git a/tests/library_checker_aizu_tests/trees/kth_path_tree_lift.test.cpp b/tests/library_checker_aizu_tests/trees/kth_path_tree_lift.test.cpp
@@ -26,12 +26,14 @@ int main() {
     {
       int w = rnd(0, n - 1);
       assert(lc.on_path(u, v, w) ==
-             (lc.dist_edges(u, w) + lc.dist_edges(w, v) ==
-              lc.dist_edges(u, v)));
+        (lc.dist_edges(u, w) + lc.dist_edges(w, v) ==
+          lc.dist_edges(u, v)));
     }
     if (u != v) {
-      assert(tl.kth_path(u, v, 1) == lc.next_on_path(u, v));
-      assert(tl.kth_path(u, v, dist_in_edges - 1) == lc.next_on_path(v, u));
+      assert(
+        tl.kth_path(u, v, 1) == lc.next_on_path(u, v));
+      assert(tl.kth_path(u, v, dist_in_edges - 1) ==
+        lc.next_on_path(v, u));
     }
   }
 }
diff --git a/tests/library_checker_aizu_tests/trees/subtree_isomorphism.test.cpp b/tests/library_checker_aizu_tests/trees/subtree_isomorphism.test.cpp
