Fix test for lazy_segment_tree.binary_search; use std::move insted copy value in segment tree binary search.

Author: Mr-Python-in-China

library/mrpython/lazy_segment_tree.hpp

@@ -157,13 +157,13 @@ class lazy_segment_tree {
       while (l % 2 == 1) l /= 2;
       T vl = mergeData(v, data[l]);
       if (check(vl)) break;
-      v = vl;
+      v = std::move(vl);
     }
     while (l < n - 1) {
       pushdown(l);
       T vl = mergeData(v, data[l * 2 + 1]);
       if (!check(vl))
-        l = l * 2 + 2, v = vl;
+        l = l * 2 + 2, v = std::move(vl);
       else
         l = l * 2 + 1;
     }
@@ -184,13 +184,13 @@ class lazy_segment_tree {
       while (r % 2 == 0) r = (r - 1) / 2;
       T vl = mergeData(v, data[r]);
       if (check(vl)) break;
-      v = vl;
+      v = std::move(vl);
     }
     while (r < n - 1) {
       pushdown(r);
-      T vr = mergeData(v, data[r * 2 + 2]);
-      if (!check(vr))
-        r = r * 2 + 1, v = vr;
+      T vl = mergeData(v, data[r * 2 + 2]);
+      if (!check(vl))
+        r = r * 2 + 1, v = std::move(vl);
       else
         r = r * 2 + 2;
     }

library/mrpython/typical_segment_tree.hpp

@@ -113,12 +113,12 @@ template <typename T, typename MergeFunction> class typical_segment_tree {
       while (l % 2 == 1) l /= 2;
       T vl = merge(v, data[l]);
       if (check(vl)) break;
-      v = vl;
+      v = std::move(vl);
     }
     while (l < n - 1) {
       T vl = merge(v, data[l * 2 + 1]);
       if (!check(vl))
-        l = l * 2 + 2, v = vl;
+        l = l * 2 + 2, v = std::move(vl);
       else
         l = l * 2 + 1;
     }
@@ -138,12 +138,12 @@ template <typename T, typename MergeFunction> class typical_segment_tree {
       while (r % 2 == 0) r = (r - 1) / 2;
       T vl = merge(v, data[r]);
       if (check(vl)) break;
-      v = vl;
+      v = std::move(vl);
     }
     while (r < n - 1) {
       T vr = merge(v, data[r * 2 + 2]);
       if (!check(vr))
-        r = r * 2 + 1, v = vr;
+        r = r * 2 + 1, v = std::move(vr);
       else
         r = r * 2 + 2;
     }

library/test/lazy_segment_tree/binary_search.cpp

@@ -15,7 +15,7 @@ TEST(lazy_segment_tree, find_first_right) {
   std::uniform_int_distribution<unsigned long long> q_dist(
       std::numeric_limits<unsigned>::min(),
       (unsigned long long)std::numeric_limits<unsigned>::max() * n);
-  std::vector<unsigned> a(n);
+  std::vector<unsigned long long> a(n);
   std::generate(a.begin(), a.end(), [&] { return val_dist(gen); });
   mrpython::lazy_segment_tree_add_add<unsigned long long> tree(a.begin(),
                                                                a.end(), 0);
@@ -24,9 +24,9 @@ TEST(lazy_segment_tree, find_first_right) {
       std::size_t l = size_dist(gen), r = size_dist(gen);
       if (l > r) std::swap(l, r);
       assert(l < r + 1);
-      unsigned long long ans =
-          std::accumulate(a.begin() + l, a.begin() + r + 1, 0ull);
-      EXPECT_EQ(tree.get(l, r + 1), ans);
+      unsigned value = val_dist(gen);
+      for (std::size_t i = l; i < r + 1; ++i) a[i] += value;
+      tree.set(l, r + 1, value);
     } else {
       std::size_t l = size_dist(gen), v = q_dist(gen);
       size_t p = l;
@@ -36,7 +36,8 @@ TEST(lazy_segment_tree, find_first_right) {
         if (s > v) break;
         ++p;
       }
-      size_t out=tree.find_first_right(l, [&](unsigned long long x) { return x > v; });
+      size_t out =
+          tree.find_first_right(l, [&](unsigned long long x) { return x > v; });
       EXPECT_EQ(out, p);
     }
   }
@@ -53,7 +54,7 @@ TEST(lazy_segment_tree, find_last_left) {
   std::uniform_int_distribution<unsigned long long> q_dist(
       std::numeric_limits<unsigned>::min(),
       (unsigned long long)std::numeric_limits<unsigned>::max() * n);
-  std::vector<unsigned> a(n);
+  std::vector<unsigned long long> a(n);
   std::generate(a.begin(), a.end(), [&] { return val_dist(gen); });
   mrpython::lazy_segment_tree_add_add<unsigned long long> tree(a.begin(),
                                                                a.end(), 0);
@@ -62,9 +63,9 @@ TEST(lazy_segment_tree, find_last_left) {
       std::size_t l = size_dist(gen), r = size_dist(gen);
       if (l > r) std::swap(l, r);
       assert(l < r + 1);
-      unsigned long long ans =
-          std::accumulate(a.begin() + l, a.begin() + r + 1, 0ull);
-      EXPECT_EQ(tree.get(l, r + 1), ans);
+      unsigned value = val_dist(gen);
+      for (std::size_t i = l; i < r + 1; ++i) a[i] += value;
+      tree.set(l, r + 1, value);
     } else {
       std::size_t l = size_dist(gen), v = q_dist(gen);
       size_t p = l;
@@ -74,7 +75,8 @@ TEST(lazy_segment_tree, find_last_left) {
         if (s > v) break;
         --p;
       }
-      size_t out=tree.find_last_left(l, [&](unsigned long long x) { return x > v; });
+      size_t out =
+          tree.find_last_left(l, [&](unsigned long long x) { return x > v; });
       EXPECT_EQ(out, p);
     }
   }