fix

Author: lrvideckis

tests/library_checker_aizu_tests/data_structures/rmq_linear.test.cpp

@@ -7,13 +7,25 @@ int main() {
   cin >> n >> q;
   vector<int> a(n);
   for (int i = 0; i < n; i++) cin >> a[i];
-  linear_rmq lin_rmq(a, less());
+  linear_rmq rmq_less(a, less());
+  linear_rmq rmq_less_equal(a, less_equal());
+  vector<int> neg_a(n);
+  for (int i = 0; i < n; i++) neg_a[i] = -a[i];
+  linear_rmq rmq_greater(neg_a, greater());
+  linear_rmq rmq_greater_equal(neg_a, greater_equal());
   while (q--) {
     int l, r;
     cin >> l >> r;
-    int idx_min = lin_rmq.query_idx(l, r - 1);
-    assert(l <= idx_min && idx_min < r);
-    assert(lin_rmq.query(l, r - 1) == a[idx_min]);
-    cout << a[idx_min] << '\n';
+    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(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));
+    int idx_left_min = rmq_less_equal.query_idx(l, r - 1);
+    assert(l <= idx_left_min && idx_left_min < r);
+    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';
   }
 }

tests/library_checker_aizu_tests/mono_st_asserts.hpp

@@ -6,7 +6,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 {
@@ -24,7 +24,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);
     }
   }
@@ -40,42 +40,17 @@ void mono_st_asserts(const vector<int>& a) {
   for (auto cmp : compares) {
     vector<int> init(n);
     iota(begin(init), end(init), 0);
-    RMQ rmq(init, [&](int x, int y) -> int {
-      return cmp(a[x], a[y]) ? x : y;
-    });
     linear_rmq lin_rmq(a, cmp);
     auto l = mono_st(a, cmp), r = mono_range(l),
          p = cart_binary_tree(l);
-    {
-      int iterations = 0;
-      queue<array<int, 3>> q;
-      q.push({0, n, -1}); // node_le, node_ri, parent
-      while (!empty(q)) {
-        auto [node_le, node_ri, node_par] = q.front();
-        q.pop();
-        if (node_le == node_ri) continue;
-        iterations++;
-        int idx_root = rmq.query(node_le, node_ri);
-        int idx_root_2 =
-          lin_rmq.query_idx(node_le, node_ri - 1);
-        assert(idx_root == idx_root_2);
-        assert(node_le <= idx_root && idx_root < node_ri);
-        assert(l[idx_root] == node_le - 1);
-        assert(r[idx_root] == node_ri);
-        assert(p[idx_root] == node_par);
-        q.push({node_le, idx_root, idx_root});
-        q.push({idx_root + 1, node_ri, idx_root});
-      }
-      assert(iterations == n);
-    }
     {
       vector old_way_ri =
-        mono_st<int>({rbegin(a), rend(a)},
-          [&](int x, int y) { return !cmp(y, x); });
+          mono_st<int>({rbegin(a), rend(a)},
+                       [&](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;