refactor (#189)

* refactor

* fix

* [auto-verifier] verify commit 3781dff

* add min left now

* rename

* [auto-verifier] verify commit 30158ac

* update

* fix test

* update test

* finally debugged it

* [auto-verifier] verify commit 8102111

* update docs

* fix

* update

* fix

* fix docs

* [auto-verifier] verify commit a2a9464

---------

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

Author: lrvideckis

.verify-helper/timestamps.remote.json

@@ -35,12 +35,12 @@
 "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",
-"tests/library_checker_aizu_tests/data_structures/simple_tree.test.cpp": "2026-02-14 20:58:21 +0000",
-"tests/library_checker_aizu_tests/data_structures/simple_tree_inc.test.cpp": "2026-02-16 16:56:58 -0700",
-"tests/library_checker_aizu_tests/data_structures/simple_tree_inc_line.test.cpp": "2026-02-16 16:56:58 -0700",
-"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/data_structures/simple_tree.test.cpp": "2026-03-01 19:25:42 -0700",
+"tests/library_checker_aizu_tests/data_structures/simple_tree_inc.test.cpp": "2026-03-01 19:20:06 -0700",
+"tests/library_checker_aizu_tests/data_structures/simple_tree_inc_line.test.cpp": "2026-03-01 19:20:06 -0700",
+"tests/library_checker_aizu_tests/data_structures/simple_tree_inc_walk.test.cpp": "2026-03-01 19:20:06 -0700",
+"tests/library_checker_aizu_tests/data_structures/simple_tree_line.test.cpp": "2026-03-01 19:25:42 -0700",
+"tests/library_checker_aizu_tests/data_structures/simple_tree_walk.test.cpp": "2026-03-01 19:25:42 -0700",
 "tests/library_checker_aizu_tests/dsu/dsu.test.cpp": "2026-02-27 15:26:53 -0700",
 "tests/library_checker_aizu_tests/dsu/dsu_bipartite.test.cpp": "2026-02-27 15:26:53 -0700",
 "tests/library_checker_aizu_tests/dsu/kruskal_tree_aizu.test.cpp": "2026-02-27 15:26:53 -0700",

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

@@ -2,13 +2,22 @@
 //! https://github.com/kth-competitive-programming/kactl/blob/main/content/data-structures/SegmentTree.h
 //! https://codeforces.com/blog/entry/118682
 //! @code
-//!   tree st1(n, INT_MAX, ranges::min);
-//!   tree st2(n, INT_MAX, [&](int x, int y) -> int {
-//!     return min(x, y);
+//!   tree st1(n, 0, [&](int vl, int vr) {
+//!     return vl + vr;
 //!   });
-//!   int idx = st2.walk(l, r, [&](int value) {
-//!     return value > x;
-//!   }); // min idx in [l, r) such that f is false
+//!   tree st(n, INT_MAX, ranges::min);
+//!   int idx = st.max_right(l, r, [&](int value) {
+//!     return value <= x;
+//!   });
+//!   // idx in [l, r]
+//!   // f(op(a[l], a[l+1], ..., a[idx-1])) is true
+//!   // f(op(a[l], a[l+1], ..., a[idx])) is false
+//!   idx = st.min_left(l, r, [&](int value) {
+//!     return value <= x;
+//!   });
+//!   // idx in [l, r]
+//!   // f(op(a[idx], ..., a[r-2], a[r-1])) is true
+//!   // f(op(a[idx-1], ..., a[r-2], a[r-1])) is false
 //! @endcode
 //! @time O(n + q log n)
 //! @space O(n)
@@ -31,5 +40,6 @@ template<class T, class F> struct tree {
     }
     return op(x, y);
   }
-#include "seg_tree_uncommon/walk.hpp"
+#include "seg_tree_uncommon/max_right.hpp"
+#include "seg_tree_uncommon/min_left.hpp"
 };

…uctures_[l,r)/seg_tree_uncommon/walk.hpp …es_[l,r)/seg_tree_uncommon/max_right.hpplibrary/data_structures_[l,r)/seg_tree_uncommon/walk.hpp renamed to library/data_structures_[l,r)/seg_tree_uncommon/max_right.hpp library/data_structures_[l,r)/seg_tree_uncommon/walk.hpp renamed to library/data_structures_[l,r)/seg_tree_uncommon/max_right.hpp

@@ -1,4 +1,4 @@
-int walk(int l, int r, const auto& f) {
+int max_right(int l, int r, const auto& f) {
   for (T x = unit; l < r;) {
     int u = l + n, v = __lg(min(u & -u, r - l));
     if (T y = op(x, s[u >> v]); f(y)) l += 1 << v, x = y;

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

@@ -0,0 +1,9 @@
+int min_left(int l, int r, const auto& f) {
+  for (T x = unit; l < r;) {
+    int u = r + n, v = __lg(min(u & -u, r - l));
+    if (T y = op(s[(u - 1) >> v], x); f(y))
+      r -= 1 << v, x = y;
+    else l = r - (1 << v) + 1;
+  }
+  return r;
+}

library/data_structures_[l,r]/seg_tree.hpp

@@ -1,20 +1,22 @@
 #pragma once
 //! https://codeforces.com/blog/entry/118682
 //! @code
-//!   {
-//!     tree st(a, [&](int vl, int vr) {
-//!       return vl & vr;
-//!     });
-//!   }
-//!   {
-//!     tree st(n, 0LL, plus<ll>{});
-//!   }
-//!   {
-//!     tree st(n, INT_MAX, ranges::min);
-//!     int idx = st.walk(l, r, [&](int value) {
-//!       return value <= x;
-//!     }); // smallest index in [l, r] s.t. f is false
-//!   }
+//!   tree st1(n, 0, [&](int vl, int vr) {
+//!     return vl + vr;
+//!   });
+//!   tree st(a, ranges::min);
+//!   int idx = st.max_right(l, r, [&](int value) {
+//!     return value <= x;
+//!   });
+//!   // idx in [l, r+1]
+//!   // f(op(a[l], a[l+1], ..., a[idx-1])) is true
+//!   // f(op(a[l], a[l+1], ..., a[idx])) is false
+//!   idx = st.min_left(l, r, [&](int value) {
+//!     return value <= x;
+//!   });
+//!   // idx in [l-1, r]
+//!   // f(op(a[idx+1], ..., a[r-1], a[r])) is true
+//!   // f(op(a[idx], ..., a[r-1], a[r])) is false
 //! @endcode
 //! @time O(n + q log n)
 //! @space O(n)
@@ -38,5 +40,6 @@ template<class T, class F> struct tree {
     while (l <= r) x = op(x, s[nxt(l, r)]);
     return x;
   }
-#include "seg_tree_uncommon/walk.hpp"
+#include "seg_tree_uncommon/max_right.hpp"
+#include "seg_tree_uncommon/min_left.hpp"
 };

…uctures_[l,r]/seg_tree_uncommon/walk.hpp …es_[l,r]/seg_tree_uncommon/max_right.hpplibrary/data_structures_[l,r]/seg_tree_uncommon/walk.hpp renamed to library/data_structures_[l,r]/seg_tree_uncommon/max_right.hpp library/data_structures_[l,r]/seg_tree_uncommon/walk.hpp renamed to library/data_structures_[l,r]/seg_tree_uncommon/max_right.hpp

@@ -1,4 +1,4 @@
-int walk(int l, int r, const auto& f) {
+int max_right(int l, int r, const auto& f) {
   if (T x = s[l + n]; f(x))
     for (l++; l <= r;) {
       int u = l + n, v = __lg(min(u & -u, r - l + 1));

library/data_structures_[l,r]/seg_tree_uncommon/min_left.hpp

@@ -0,0 +1,10 @@
+int min_left(int l, int r, const auto& f) {
+  if (T x = s[r + n]; f(x))
+    for (r--; l <= r;) {
+      int u = r + 1 + n, v = __lg(min(u & -u, r - l + 1));
+      if (T y = op(s[(u - 1) >> v], x); f(y))
+        r -= 1 << v, x = y;
+      else l = r - (1 << v) + 2;
+    }
+  return r;
+}

tests/.config/.code_snippet_excluded_file_list

@@ -22,3 +22,5 @@ prev.hpp
 next.hpp
 wavelet_count_less.hpp
 dynamic_bitset.hpp
+max_right.hpp
+min_left.hpp

tests/library_checker_aizu_tests/data_structures/simple_tree_inc_line.test.cpp

@@ -15,6 +15,7 @@ int main() {
       return {int(1LL * l[0] * r[0] % mod),
         int((1LL * r[0] * l[1] + r[1]) % mod)};
     });
+  const array<int, 2> unit = {1, 0};
   while (q--) {
     int type;
     cin >> type;
@@ -25,8 +26,49 @@ int main() {
     } else {
       int l, r, x;
       cin >> l >> r >> x;
-      auto [slope, y_int] = st.query(l, r - 1);
-      cout << (1LL * slope * x + y_int) % mod << '\n';
+      r--;
+      array<int, 2> res = st.query(l, r);
+      {
+        array<int, 2> walk_res = {1, 0};
+        int idx = st.max_right(l, r,
+          [&](const array<int, 2>& curr_line) -> bool {
+            walk_res = curr_line;
+            return 1;
+          });
+        assert(res == walk_res);
+        assert(idx == r + 1);
+      }
+      {
+        array<int, 2> walk_res = unit;
+        int idx = st.max_right(l, r,
+          [&](const array<int, 2>& curr_line) -> bool {
+            walk_res = curr_line;
+            return 0;
+          });
+        assert(walk_res == st.query(l, l));
+        assert(idx == l);
+      }
+      {
+        array<int, 2> walk_res = unit;
+        int idx = st.min_left(l, r,
+          [&](const array<int, 2>& curr_line) -> bool {
+            walk_res = curr_line;
+            return 1;
+          });
+        assert(walk_res == res);
+        assert(idx == l - 1);
+      }
+      {
+        array<int, 2> walk_res = unit;
+        int idx = st.min_left(l, r,
+          [&](const array<int, 2>& curr_line) -> bool {
+            walk_res = curr_line;
+            return 0;
+          });
+        assert(walk_res == st.query(r, r));
+        assert(idx == r);
+      }
+      cout << (1LL * res[0] * x + res[1]) % mod << '\n';
     }
   }
   return 0;

tests/library_checker_aizu_tests/data_structures/simple_tree_inc_walk.test.cpp

@@ -10,7 +10,7 @@ int main() {
   cin >> s;
   vector<int> init(n);
   for (int i = 0; i < n; i++) init[i] = s[i] - '0';
-  tree st(init, plus<int>{});
+  tree st(init, ranges::max);
   while (q--) {
     int type, k;
     cin >> type >> k;
@@ -21,21 +21,16 @@ int main() {
     } else if (type == 2) {
       cout << st.query(k, k) << '\n';
     } else if (type == 3) {
-      // returns first element in [k,n-1] such that sum > 0
-      int idx = st.walk(k, n - 1,
-        [&](int sum) { return sum == 0; });
+      // returns first element in [k,n-1] such that mx > 0
+      int idx = st.max_right(k, n - 1,
+        [&](int mx) { return mx == 0; });
       if (idx == n) idx = -1;
       cout << idx << '\n';
     } else {
       assert(type == 4);
-      int total = st.query(0, k);
-      if (total == 0) {
-        cout << -1 << '\n';
-      } else {
-        cout << st.walk(0, k, [&](int sum) {
-          return sum < total;
-        }) << '\n';
-      }
+      cout << st.min_left(0, k, [&](int mx) {
+        return mx == 0;
+      }) << '\n';
     }
   }
   return 0;