Merge branch 'dev' into remove-some-docs

Author: lrvideckis

.verify-helper/timestamps.remote.json

@@ -23,29 +23,29 @@ struct seg_tree {
     }
   }
   void update(int l, int r, ll change) {
-    update_impl(l, r, change, 0, n, 1);
+    update(l, r, change, 0, n, 1);
   }
-  void update_impl(int l, int r, ll change, int tl, int tr,
+  void update(int l, int r, ll change, int tl, int tr,
     int v) {
     if (r <= tl || tr <= l) return;
     if (l <= tl && tr <= r)
       return apply(change, tl, tr, v);
     int tm = split(tl, tr);
     push(tl, tm, tr, v);
-    update_impl(l, r, change, tl, tm, 2 * v);
-    update_impl(l, r, change, tm, tr, 2 * v + 1);
+    update(l, r, change, tl, tm, 2 * v);
+    update(l, r, change, tm, tr, 2 * v + 1);
     tree[v] = op(tree[2 * v], tree[2 * v + 1]);
   }
   ll query(int l, int r) {
-    return query_impl(l, r, 0, n, 1);
+    return query(l, r, 0, n, 1);
   }
-  ll query_impl(int l, int r, int tl, int tr, int v) {
+  ll query(int l, int r, int tl, int tr, int v) {
     if (r <= tl || tr <= l) return 0;
     if (l <= tl && tr <= r) return tree[v];
     int tm = split(tl, tr);
     push(tl, tm, tr, v);
-    return op(query_impl(l, r, tl, tm, 2 * v),
-      query_impl(l, r, tm, tr, 2 * v + 1));
+    return op(query(l, r, tl, tm, 2 * v),
+      query(l, r, tm, tr, 2 * v + 1));
   }
 #include "seg_tree_uncommon/find_first.hpp"
 #include "seg_tree_uncommon/find_last.hpp"

library/data_structures_[l,r)/lazy_seg_tree.hpp

@@ -20,18 +20,18 @@ struct kth_smallest {
   //! @space O(log(maxv - minv)) for recursion stack; no
   //! new nodes are allocated
   int query(int l, int r, int k) {
-    return query_impl(k, pst.root_l, pst.root_r,
-      pst.roots[l], pst.roots[r]);
+    return query(k, pst.root_l, pst.root_r, pst.roots[l],
+      pst.roots[r]);
   }
-  int query_impl(int k, int tl, int tr, int vl, int vr) {
+  int query(int k, int tl, int tr, int vl, int vr) {
     if (tr - tl == 1) return tl;
     int tm = tl + (tr - tl) / 2;
     int left_count = pst.tree[pst.tree[vr].lch].sum -
       pst.tree[pst.tree[vl].lch].sum;
     if (left_count >= k)
-      return query_impl(k, tl, tm, pst.tree[vl].lch,
+      return query(k, tl, tm, pst.tree[vl].lch,
         pst.tree[vr].lch);
-    return query_impl(k - left_count, tm, tr,
-      pst.tree[vl].rch, pst.tree[vr].rch);
+    return query(k - left_count, tm, tr, pst.tree[vl].rch,
+      pst.tree[vr].rch);
   }
 };

library/data_structures_[l,r)/seg_tree_uncommon/kth_smallest_query.hpp

@@ -14,16 +14,16 @@ struct merge_sort_tree {
   //! @time O(log(n)^2)
   //! @space O(1)
   int query(int l, int r, int vl, int vr) {
-    return query_impl(l, r, vl, vr, 0, n, 1);
+    return query(l, r, vl, vr, 0, n, 1);
   }
-  int query_impl(int l, int r, int vl, int vr, int tl,
-    int tr, int v) {
+  int query(int l, int r, int vl, int vr, int tl, int tr,
+    int v) {
     if (r <= tl || tr <= l) return 0;
     if (l <= tl && tr <= r)
       return ranges::lower_bound(tree[v], vr) -
         ranges::lower_bound(tree[v], vl);
     int tm = split(tl, tr);
-    return query_impl(l, r, vl, vr, tl, tm, 2 * v) +
-      query_impl(l, r, vl, vr, tm, tr, 2 * v + 1);
+    return query(l, r, vl, vr, tl, tm, 2 * v) +
+      query(l, r, vl, vr, tm, tr, 2 * v + 1);
   }
 };

library/data_structures_[l,r)/seg_tree_uncommon/merge_sort_tree.hpp

@@ -22,34 +22,31 @@ struct PST {
     root_l(root_l), root_r(root_r), roots(1),
     tree(1, {0LL, 0, 0}) {}
   void update(int idx, ll change, int version) {
-    roots.push_back(update_impl(idx, change, root_l,
-      root_r, roots[version]));
+    roots.push_back(
+      update(idx, change, root_l, root_r, roots[version]));
   }
-  int update_impl(int idx, ll change, int tl, int tr,
-    int v) {
+  int update(int idx, ll change, int tl, int tr, int v) {
     if (tr - tl == 1) {
       tree.emplace_back(tree[v].sum + change, 0, 0);
       return sz(tree) - 1;
     }
     int tm = tl + (tr - tl) / 2;
     int lch = tree[v].lch;
     int rch = tree[v].rch;
-    if (idx < tm)
-      lch = update_impl(idx, change, tl, tm, lch);
-    else rch = update_impl(idx, change, tm, tr, rch);
+    if (idx < tm) lch = update(idx, change, tl, tm, lch);
+    else rch = update(idx, change, tm, tr, rch);
     tree.emplace_back(tree[lch].sum + tree[rch].sum, lch,
       rch);
     return sz(tree) - 1;
   }
   ll query(int l, int r, int version) {
-    return query_impl(l, r, root_l, root_r,
-      roots[version]);
+    return query(l, r, root_l, root_r, roots[version]);
   }
-  ll query_impl(int l, int r, int tl, int tr, int v) {
+  ll query(int l, int r, int tl, int tr, int v) {
     if (v == 0 || r <= tl || tr <= l) return 0;
     if (l <= tl && tr <= r) return tree[v].sum;
     int tm = tl + (tr - tl) / 2;
-    return query_impl(l, r, tl, tm, tree[v].lch) +
-      query_impl(l, r, tm, tr, tree[v].rch);
+    return query(l, r, tl, tm, tree[v].lch) +
+      query(l, r, tm, tr, tree[v].rch);
   }
 };