Add find_last_left method for typical_segment_tree

Author: Mr-Python-in-China

.gitignore

@@ -7,3 +7,4 @@ library/test.exe
 library/test.d
 .yarn/
 *.gch
+tmp/

library/mrpython/typical_segment_tree.hpp

@@ -101,6 +101,7 @@ template <typename T, typename MergeFunction> class typical_segment_tree {
   T getd(size_t l, size_t r, T const& e = {}) { return l == r ? e : get(l, r); }
   template <typename Check>
   size_t find_first_right(size_t l, Check const& check) {
+    if (l >= n) return l;
     l = data_id_to_node_id(l);
     while (l % 2 == 1) l /= 2;
     while (l < 2 * n - 1 && check(data[l])) l = l * 2 + 1;
@@ -120,6 +121,28 @@ template <typename T, typename MergeFunction> class typical_segment_tree {
     }
     return node_id_to_data_id(l);
   }
+  template <typename Check>
+  size_t find_last_left(size_t r, Check const& check) {
+    if (r >= n) return r;
+    r = data_id_to_node_id(r);
+    while (r && r % 2 == 0) r = (r - 1) / 2;
+    while (r < 2 * n - 1 && check(data[r])) r = r * 2 + 2;
+    if (r >= 2 * n - 1) return node_id_to_data_id((r - 1) / 2);
+    T v = data[r];
+    do {
+      if (!(r & (r + 1))) return -1;
+      --r;
+      while (r % 2 == 0) r = (r - 1) / 2;
+    } while (!check(data[r]));
+    while (r < n - 1) {
+      T vr = merge(v, data[r * 2 + 2]);
+      if (!check(vr))
+        r = r * 2 + 1, v = vr;
+      else
+        r = r * 2 + 2;
+    }
+    return node_id_to_data_id(r);
+  }
 };
 template <typename T>
 using typical_segment_tree_add = typical_segment_tree<T, std::plus<T>>;

library/test/typical_segment_tree/typical_segment_tree_min.cpp

@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
 
+#include <cstddef>
 #include <mrpython/typical_segment_tree.hpp>
-#include <numeric>
 #include <random>
 
 TEST(typical_segment_tree, min) {
@@ -30,14 +30,14 @@ TEST(typical_segment_tree, min) {
   }
 }
 
-TEST(typicaL_segment_tree, fist_first_right) {
+TEST(typicaL_segment_tree, find_first_right) {
   std::mt19937_64 gen(std::random_device{}());
   std::size_t n = std::uniform_int_distribution<std::size_t>{1, 5000}(gen),
               q = std::uniform_int_distribution<std::size_t>{1, 5000}(gen);
   std::vector<int> a(n);
   std::uniform_int_distribution<int> val_dist(std::numeric_limits<int>::min(),
                                               std::numeric_limits<int>::max());
-  std::uniform_int_distribution<std::size_t> size_dist(0, n - 1),
+  std::uniform_int_distribution<std::size_t> size_dist(0, n),
       operator_dist(0, 1);
   std::generate(a.begin(), a.end(), [&] { return val_dist(gen); });
   mrpython::typical_segment_tree_min<int> tree(a.begin(), a.end());
@@ -49,3 +49,24 @@ TEST(typicaL_segment_tree, fist_first_right) {
     EXPECT_EQ(tree.find_first_right(l, check), ans);
   }
 }
+
+TEST(typicaL_segment_tree, find_last_left) {
+  std::mt19937_64 gen(std::random_device{}());
+  std::size_t n = std::uniform_int_distribution<std::size_t>{1, 5000}(gen),
+              q = std::uniform_int_distribution<std::size_t>{1, 5000}(gen);
+  std::vector<int> a(n);
+  std::uniform_int_distribution<int> val_dist(std::numeric_limits<int>::min(),
+                                              std::numeric_limits<int>::max());
+  std::uniform_int_distribution<std::size_t> size_dist(0, n),
+      operator_dist(0, 1);
+  std::generate(a.begin(), a.end(), [&] { return val_dist(gen); });
+  mrpython::typical_segment_tree_min<int> tree(a.begin(), a.end());
+  while (q--) {
+    std::size_t l = size_dist(gen) - 1;
+    int tv = val_dist(gen);
+    auto check = [tv](int x) { return x <= tv; };
+    size_t ans = a.rend() - std::find_if(a.rend() - l - 1, a.rend(), check) - 1;
+    size_t out = tree.find_last_left(l, check);
+    EXPECT_EQ(out, ans);
+  }
+}