lots of nits (#188)

* lots of nits

* [auto-verifier] verify commit b9ac2cf

* more nits

* even more nits

* [auto-verifier] verify commit 2cba688

* nits/golf

* [auto-verifier] verify commit 854f12e

* update

* fix

* another fix

---------

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

Author: lrvideckis

.verify-helper/timestamps.remote.json

@@ -18,26 +18,20 @@
 "tests/library_checker_aizu_tests/data_structures/disjoint_rmq_inc_lines.test.cpp": "2026-01-18 11:15:41 +0000",
 "tests/library_checker_aizu_tests/data_structures/disjoint_rmq_inc_sum.test.cpp": "2026-01-18 11:15:41 +0000",
 "tests/library_checker_aizu_tests/data_structures/distinct_query.test.cpp": "2026-01-18 11:15:41 +0000",
-"tests/library_checker_aizu_tests/data_structures/dsu.test.cpp": "2026-01-22 10:08:22 -0700",
-"tests/library_checker_aizu_tests/data_structures/dsu_bipartite.test.cpp": "2026-01-18 02:20:40 +0000",
 "tests/library_checker_aizu_tests/data_structures/implicit_seg_tree.test.cpp": "2026-01-18 11:15:41 +0000",
 "tests/library_checker_aizu_tests/data_structures/kd_bit_1d.test.cpp": "2026-02-19 18:06:52 -0700",
-"tests/library_checker_aizu_tests/data_structures/kruskal_tree_aizu.test.cpp": "2026-01-18 02:20:40 +0000",
 "tests/library_checker_aizu_tests/data_structures/kth_smallest_pst.test.cpp": "2026-01-18 11:15:41 +0000",
 "tests/library_checker_aizu_tests/data_structures/kth_smallest_wavelet_matrix.test.cpp": "2026-02-04 02:50:53 +0000",
 "tests/library_checker_aizu_tests/data_structures/lazy_segment_tree.test.cpp": "2026-01-23 04:31:29 +0000",
 "tests/library_checker_aizu_tests/data_structures/lazy_segment_tree_constructor.test.cpp": "2026-01-23 04:31:29 +0000",
 "tests/library_checker_aizu_tests/data_structures/lazy_segment_tree_inc.test.cpp": "2026-02-05 13:02:29 -0700",
 "tests/library_checker_aizu_tests/data_structures/lazy_segment_tree_inc_constructor.test.cpp": "2026-02-05 13:02:29 -0700",
-"tests/library_checker_aizu_tests/data_structures/line_tree_aizu.test.cpp": "2026-01-18 11:15:41 +0000",
-"tests/library_checker_aizu_tests/data_structures/line_tree_lib_checker.test.cpp": "2026-01-18 02:20:40 +0000",
 "tests/library_checker_aizu_tests/data_structures/merge_sort_tree.test.cpp": "2026-01-18 11:04:58 +0000",
 "tests/library_checker_aizu_tests/data_structures/mode_query.test.cpp": "2026-01-18 02:20:40 +0000",
 "tests/library_checker_aizu_tests/data_structures/permutation_tree.test.cpp": "2026-01-18 11:15:41 +0000",
 "tests/library_checker_aizu_tests/data_structures/persistent_queue_tree.test.cpp": "2026-01-18 11:15:41 +0000",
 "tests/library_checker_aizu_tests/data_structures/persistent_seg_tree.test.cpp": "2026-01-18 11:15:41 +0000",
 "tests/library_checker_aizu_tests/data_structures/pq_ds_undo_sliding_window.test.cpp": "2026-01-18 02:20:40 +0000",
-"tests/library_checker_aizu_tests/data_structures/range_parallel_dsu.test.cpp": "2026-01-22 10:08:22 -0700",
 "tests/library_checker_aizu_tests/data_structures/rmq_linear.test.cpp": "2026-01-18 11:15:41 +0000",
 "tests/library_checker_aizu_tests/data_structures/rmq_sparse_table.test.cpp": "2026-01-18 11:15:41 +0000",
 "tests/library_checker_aizu_tests/data_structures/rmq_sparse_table_inc.test.cpp": "2026-01-18 11:15:41 +0000",
@@ -47,6 +41,12 @@
 "tests/library_checker_aizu_tests/data_structures/simple_tree_inc_walk.test.cpp": "2026-02-16 16:56:58 -0700",
 "tests/library_checker_aizu_tests/data_structures/simple_tree_line.test.cpp": "2026-02-14 20:58:21 +0000",
 "tests/library_checker_aizu_tests/data_structures/simple_tree_walk.test.cpp": "2026-02-14 20:58:21 +0000",
+"tests/library_checker_aizu_tests/dsu/dsu.test.cpp": "2026-02-27 11:50:42 -0700",
+"tests/library_checker_aizu_tests/dsu/dsu_bipartite.test.cpp": "2026-02-27 11:58:10 -0700",
+"tests/library_checker_aizu_tests/dsu/kruskal_tree_aizu.test.cpp": "2026-02-27 11:50:42 -0700",
+"tests/library_checker_aizu_tests/dsu/line_tree_aizu.test.cpp": "2026-02-27 11:56:18 -0700",
+"tests/library_checker_aizu_tests/dsu/line_tree_lib_checker.test.cpp": "2026-02-27 11:56:18 -0700",
+"tests/library_checker_aizu_tests/dsu/range_parallel_dsu.test.cpp": "2026-02-27 14:31:41 -0700",
 "tests/library_checker_aizu_tests/flow/dinic_aizu.test.cpp": "2024-11-17 14:04:03 -0600",
 "tests/library_checker_aizu_tests/flow/hungarian.test.cpp": "2024-11-17 14:04:03 -0600",
 "tests/library_checker_aizu_tests/flow/min_cost_max_flow.test.cpp": "2024-12-05 10:41:42 -0600",

library/dsu/dsu_bipartite.hpp

@@ -3,34 +3,28 @@
 //! DSU with support for parity of path to root for online
 //! bipartite check
 struct dsu_bipartite {
-  int num_sets;
   vi p, is_bi, parity;
-  dsu_bipartite(int n):
-    num_sets(n), p(n, -1), is_bi(n, 1), parity(n) {}
-  int find(int v) {
+  dsu_bipartite(int n): p(n, -1), is_bi(n, 1), parity(n) {}
+  int f(int v) {
     if (p[v] < 0) return v;
-    int root = find(p[v]);
+    int root = f(p[v]);
     parity[v] ^= parity[p[v]];
     return p[v] = root;
   }
   bool join(int u, int v) {
-    int root_u = find(u), root_v = find(v);
-    if (root_u == root_v) {
-      if (parity[u] == parity[v]) is_bi[root_u] = 0;
+    int root_u = f(u), root_v = f(v);
+    int new_parity = parity[v] ^ parity[u];
+    u = root_u, v = root_v;
+    if (u == v) {
+      is_bi[u] &= new_parity;
       return 0;
     }
-    if (p[root_u] > p[root_v]) {
-      swap(u, v);
-      swap(root_u, root_v);
-    }
-    is_bi[root_u] &= is_bi[root_v];
-    parity[root_v] = parity[v] ^ 1 ^ parity[u];
-    p[root_u] += p[root_v], p[root_v] = root_u, num_sets--;
+    if (p[u] > p[v]) swap(u, v);
+    is_bi[u] &= is_bi[v];
+    parity[v] = new_parity ^ 1;
+    p[u] += p[v], p[v] = u;
     return 1;
   }
-  int size(int v) { return -p[find(v)]; }
-  bool same_set(int u, int v) {
-    return find(u) == find(v);
-  }
-  bool is_bipartite(int v) { return is_bi[find(v)]; }
+  int size(int v) { return -p[f(v)]; }
+  bool is_bipartite(int v) { return is_bi[f(v)]; }
 };

library/dsu/kruskal_tree.hpp

@@ -7,11 +7,9 @@ struct kr_tree {
   vi p;
   vector<vi> adj;
   kr_tree(int n): id(n), p(2 * n, -1), adj(2 * n) {}
-  int find(int v) {
-    return p[v] < 0 ? v : p[v] = find(p[v]);
-  }
+  int f(int v) { return p[v] < 0 ? v : p[v] = f(p[v]); }
   bool join(int u, int v) {
-    if ((u = find(u)) == (v = find(v))) return 0;
+    if ((u = f(u)) == (v = f(v))) return 0;
     return adj[p[u] = p[v] = id++] = {u, v}, 1;
   }
 };

library/dsu/line_tree.hpp

@@ -4,14 +4,14 @@
 //!   ranges::sort(w_eds);
 //!   line_tree lt(n);
 //!   for (auto [w, u, v] : w_eds) lt.join(u, v);
-//!   for (int v = lt.find(0); v != -1;) {
+//!   for (int v = lt.f(0); v != -1;) {
 //!     auto [next, e_id] = lt.edge[v];
 //!     int w = w_eds[e_id][0];
 //!     //
 //!     v = next;
 //!   }
 //! @endcode
-//! lt.find(v) = head of linked list
+//! lt.f(v) = head of linked list
 //!   of component containing v
 //! @time O(n + m * \alpha(n))
 //! @space O(n + m)
@@ -22,16 +22,14 @@ struct line_tree {
   line_tree(int n): p(n, -1), last(n), edge(n, {-1, -1}) {
     iota(all(last), 0);
   }
-  int size(int v) { return -p[find(v)]; }
-  int find(int v) {
-    return p[v] < 0 ? v : p[v] = find(p[v]);
-  }
+  int size(int v) { return -p[f(v)]; }
+  int f(int v) { return p[v] < 0 ? v : p[v] = f(p[v]); }
   bool join(int u, int v) {
-    u = find(u), v = find(v), id++;
+    u = f(u), v = f(v), id++;
     if (u == v) return 0;
     if (p[u] < p[v]) swap(u, v);
     p[v] += p[u], p[u] = v;
-    edge[exchange(last[v], last[u])] = {u, id - 1};
+    edge[last[v]] = {u, id - 1}, last[v] = last[u];
     return 1;
   }
 };

library/dsu/range_parallel_dsu.hpp

@@ -1,31 +1,23 @@
 #pragma once
 #include "dsu.hpp"
-//! Given l1,l2,len; joins (l1,l2), (l1+1,l2+1),
-//!   ..., (l1+len-1,l2+len-1)
+//! Given u,v,len; joins (u,v), (u+1,v+1),
+//!   ..., (u+len-1,v+len-1)
 //! `f` is called at most n-1 times
 //! @time O(n*log(n)*\alpha(n) + q)
 //! @space O(n log n)
 struct rp_dsu {
   vector<DSU> dsus;
-  rp_dsu(int n): dsus(bit_width(unsigned(n)), DSU(n)) {}
-  void join(int l1, int l2, int len, const auto& f) {
-    if (len == 0) return;
-    int lg = __lg(len);
-    join_impl(lg, l1, l2, f);
-    join_impl(lg, l1 + len - (1 << lg),
-      l2 + len - (1 << lg), f);
+  rp_dsu(int n): dsus(bit_width(n + 0u), DSU(n)) {}
+  void join(int u, int v, int len, const auto& f) {
+    int i = __lg(len);
+    join(u, v, f, i);
+    join(u + len - (1 << i), v + len - (1 << i), f, i);
   }
-  void join_impl(int lvl, int u, int v, const auto& f) {
-    if (lvl == 0) {
-      u = dsus[0].f(u);
-      v = dsus[0].f(v);
-      if (!dsus[0].join(v, u)) return;
-      int w = dsus[0].f(u);
-      return f(w, u ^ v ^ w);
-    }
-    if (!dsus[lvl].join(u, v)) return;
-    join_impl(lvl - 1, u, v, f);
-    join_impl(lvl - 1, u + (1 << (lvl - 1)),
-      v + (1 << (lvl - 1)), f);
+  void join(int u, int v, const auto& f, int i) {
+    if (!dsus[i].join(u, v)) return;
+    if (i == 0) return f(u, v);
+    i--;
+    join(u, v, f, i);
+    join(u + (1 << i), v + (1 << i), f, i);
   }
 };

library/dsu/range_parallel_equivalence_classes.hpp

@@ -1,17 +1,23 @@
 #pragma once
 #include "dsu.hpp"
-//! Given triplets (l1,l2,len); joins (l1,l2),
-//!   (l1+1,l2+1), ..., (l1+len-1,l2+len-1)
+//! @code
+//!   vector<vector<pii>> joins(n + 1);
+//!   joins[len].emplace_back(u, v);
+//!   // it does:
+//!   // dsu.join(u + 0, v + 0);
+//!   // dsu.join(u + 1, v + 1);
+//!   // dsu.join(u + 2, v + 2);
+//!   // ...
+//!   // dsu.join(u + len - 1, v + len - 1);
+//!   DSU dsu = get_rp_dsu(joins, n);
+//! @endcode
 //! @time O((n + q) * \alpha(n))
 //! @space O(n + q)
-DSU get_rp_dsu(const vector<array<int, 3>>& rests, int n) {
-  vector<vector<pii>> rests_by_len(n + 1);
-  for (auto [l1, l2, len] : rests)
-    rests_by_len[len].emplace_back(l1, l2);
+DSU get_rp_dsu(vector<vector<pii>>& joins, int n) {
   DSU dsu(n);
-  for (int len = n; len > 0; len--)
-    for (auto [l1, l2] : rests_by_len[len])
-      if (dsu.join(l1, l2))
-        rests_by_len[len - 1].emplace_back(l1 + 1, l2 + 1);
+  for (int i = n; i; i--)
+    for (auto [u, v] : joins[i])
+      if (dsu.join(u, v))
+        joins[i - 1].emplace_back(u + 1, v + 1);
   return dsu;
 }

tests/.config/.cppcheck_suppression_list

@@ -41,7 +41,7 @@ syntaxError:../library/math/prime_sieve/mobius.hpp:6
 syntaxError:../library/trees/lca_rmq/iterate_subtree.hpp:6
 knownConditionTrueFalse:../library/strings/suffix_array/suffix_array.hpp:62
 knownConditionTrueFalse:../library/strings/suffix_array/suffix_array_short.hpp:34
-knownConditionTrueFalse:../library/dsu/kruskal_tree.hpp:15
+knownConditionTrueFalse:../library/dsu/kruskal_tree.hpp:13
 knownConditionTrueFalse:../library/dsu/dsu.hpp:11
 constVariable:../kactl/content/numerical/NumberTheoreticTransform.h:30
 constVariable:../kactl/content/graph/CompressTree.h:20

…_aizu_tests/data_structures/dsu.test.cpp …rary_checker_aizu_tests/dsu/dsu.test.cpptests/library_checker_aizu_tests/data_structures/dsu.test.cpp renamed to tests/library_checker_aizu_tests/dsu/dsu.test.cpp tests/library_checker_aizu_tests/data_structures/dsu.test.cpp renamed to tests/library_checker_aizu_tests/dsu/dsu.test.cpp

@@ -42,8 +42,8 @@ int main() {
       dsu.join(u, v);
       adj[u].push_back(v);
       adj[v].push_back(u);
-    } else cout << dsu.same_set(u, v) << '\n';
-    if (rnd<int>(0, 20'000) == 0) check();
+    } else cout << (dsu.f(u) == dsu.f(v)) << '\n';
+    if (i <= 20 || rnd<int>(0, 20'000) == 0) check();
   }
   check();
   return 0;