now inc-exc changes

Author: lrvideckis

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

@@ -6,18 +6,14 @@
 //!     return vl + vr;
 //!   });
 //!   tree st(n, INT_MAX, ranges::min);
-//!   int idx = st.max_right(l, r, [&](int value) {
+//!   int idx = st.max_right(l, r, [&](int m, int value) {
+//!     // value = op(a[l], a[l+1], ..., a[m-1])
 //!     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) {
+//!   idx = st.min_left(l, r, [&](int m, int value) {
+//!     // value = op(a[m], ..., a[r-2], a[r-1])
 //!     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)

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

@@ -1,8 +1,8 @@
-int max_right(int l, int r, const auto& f) {
+void 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;
-    else r = l + (1 << v) - 1;
+    int u = l + n, v = __lg(min(u & -u, r - l)),
+        m = l + (1 << v);
+    if (T y = op(x, s[u >> v]); f(m, y)) l = m, x = y;
+    else r = m - 1;
   }
-  return l;
 }

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

@@ -1,9 +1,9 @@
-int min_left(int l, int r, const auto& f) {
+void 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;
+    int u = r + n, v = __lg(min(u & -u, r - l)),
+        m = r - (1 << v);
+    if (T y = op(s[(u - 1) >> v], x); f(m, y))
+      r = m, x = y;
+    else l = m + 1;
   }
-  return r;
 }

tests/library_checker_aizu_tests/data_structures/simple_tree_line.test.cpp

@@ -34,43 +34,55 @@ int main() {
       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 {
+        int idx = -1;
+        st.max_right(l, r,
+          [&](int m,
+            const array<int, 2>& curr_line) -> bool {
             walk_res = curr_line;
+            idx = m;
             return 1;
           });
         assert(res == walk_res);
         assert(idx == r);
       }
       {
         array<int, 2> walk_res = unit;
-        int idx = st.max_right(l, r,
-          [&](const array<int, 2>& curr_line) -> bool {
+        int idx = -1;
+        st.max_right(l, r,
+          [&](int m,
+            const array<int, 2>& curr_line) -> bool {
             walk_res = curr_line;
+            idx = m;
             return 0;
           });
         assert(walk_res == st.query(l, l + 1));
-        assert(idx == l);
+        assert(idx == l + 1);
       }
       {
         array<int, 2> walk_res = unit;
-        int idx = st.min_left(l, r,
-          [&](const array<int, 2>& curr_line) -> bool {
+        int idx = -1;
+        st.min_left(l, r,
+          [&](int m,
+            const array<int, 2>& curr_line) -> bool {
             walk_res = curr_line;
+            idx = m;
             return 1;
           });
         assert(walk_res == res);
         assert(idx == l);
       }
       {
         array<int, 2> walk_res = unit;
-        int idx = st.min_left(l, r,
-          [&](const array<int, 2>& curr_line) -> bool {
+        int idx = -1;
+        st.min_left(l, r,
+          [&](int m,
+            const array<int, 2>& curr_line) -> bool {
             walk_res = curr_line;
+            idx = m;
             return 0;
           });
         assert(walk_res == st.query(r - 1, r));
-        assert(idx == r);
+        assert(idx == r - 1);
       }
       cout << (1LL * res[0] * x + res[1]) % mod << '\n';
     }

tests/library_checker_aizu_tests/data_structures/simple_tree_walk.test.cpp

@@ -21,15 +21,22 @@ int main() {
       cout << st.query(k, k + 1) << '\n';
     } else if (type == 3) {
       // returns first element in [k,n) such that mx > 0
-      int idx = st.max_right(k, n,
-        [&](int mx) { return mx == 0; });
-      if (idx == n) idx = -1;
+      int idx = -1;
+      st.max_right(k, n, [&](int m, int mx) {
+        if (mx == 0) return 1;
+        idx = m - 1;
+        return 0;
+      });
       cout << idx << '\n';
     } else {
       assert(type == 4);
-      cout << st.min_left(0, k + 1,
-                [&](int mx) { return mx == 0; }) -
-          1 << '\n';
+      int idx = -1;
+      st.min_left(0, k + 1, [&](int m, int mx) {
+        if (mx == 0) return 1;
+        idx = m;
+        return 0;
+      });
+      cout << idx << '\n';
     }
   }
   return 0;