refactor: Update SegmentTree initialization to use SegmentTreeStoreSon for improved structure

Author: weilycoder

test/point_set_range_composite.test.cpp

@@ -36,7 +36,7 @@ int main() {
     affines.emplace_back(a, b);
   }
 
-  SegmentTree<AffineMonoid> sgt(affines);
+  SegmentTree<SegmentTreeStoreSon<AffineMonoid>> sgt(affines);
   while (q--) {
     size_t op;
     cin >> op;

weilycoder/ds/segment_tree.hpp

@@ -12,122 +12,134 @@
 #include <vector>
 
 namespace weilycoder {
-/**
- * @brief Segment Tree (point update and range query)
- * @tparam Monoid The monoid defining the operation and identity
- * @tparam ptr_t The type used for indexing (default: size_t)
- */
-template <typename Monoid, typename ptr_t = size_t> struct SegmentTree {
-  using T = typename Monoid::value_type;
+template <typename _Monoid, typename _ptr_t = size_t> struct SegmentTreeStoreSon {
+protected:
+  using T = typename _Monoid::value_type;
+  using ptr_t = _ptr_t;
+  using Monoid = _Monoid;
   static constexpr ptr_t null = std::numeric_limits<ptr_t>::max();
 
-  /**
-   * @brief Node structure for the segment tree
-   */
+private:
   struct Node {
     T value;
     ptr_t left, right;
 
     Node() : value(Monoid::identity()), left(null), right(null) {}
   };
 
-private:
-  ptr_t tl, tr;
+  ptr_t st, ed;
   std::vector<Node> data;
 
-  void pushup(size_t node) {
-    data[node].value =
-        Monoid::operation(data[data[node].left].value, data[data[node].right].value);
-  }
-
-  ptr_t init(ptr_t l, ptr_t r) {
+  ptr_t build(ptr_t l, ptr_t r) {
     ptr_t node = data.size();
     data.emplace_back();
-
     if (r - l > 1) {
       ptr_t mid = l + ((r - l) >> 1);
-      ptr_t left = init(l, mid), right = init(mid, r);
+      ptr_t left = build(l, mid), right = build(mid, r);
       data[node].left = left, data[node].right = right;
     }
-
     return node;
   }
 
   ptr_t init(ptr_t l, ptr_t r, const std::vector<T> &arr) {
     ptr_t node = data.size();
     data.emplace_back();
-
-    if (r - l == 1)
+    if (r - l == 1) {
       data[node].value = arr[l];
-    else {
+    } else {
       ptr_t mid = l + ((r - l) >> 1);
-      ptr_t left = init(l, mid, arr);
-      ptr_t right = init(mid, r, arr);
+      ptr_t left = init(l, mid, arr), right = init(mid, r, arr);
       data[node].left = left, data[node].right = right;
       pushup(node);
     }
-
     return node;
   }
 
-  void build(ptr_t l, ptr_t r) {
-    if (r - l > 0) {
-      data.reserve((r - l) * 2 - 1);
-      init(l, r);
-    }
+protected:
+  ptr_t get_st() const { return st; }
+  ptr_t get_ed() const { return ed; }
+
+  T &get_value(ptr_t node) { return data[node].value; }
+  const T &get_value(ptr_t node) const { return data[node].value; }
+
+  ptr_t get_lc(ptr_t node) const { return data[node].left; }
+  ptr_t get_rc(ptr_t node) const { return data[node].right; }
+
+  void pushdown(ptr_t node) const {}
+  void pushup(ptr_t node) {
+    data[node].value =
+        Monoid::operation(data[data[node].left].value, data[data[node].right].value);
   }
 
-  void build(const std::vector<T> &arr) {
-    if (!arr.empty()) {
-      data.reserve(arr.size() * 2 - 1);
-      init(0, arr.size(), arr);
-    }
+  explicit SegmentTreeStoreSon(ptr_t size) : st(0), ed(size) {
+    data.reserve(size * 2 - 1);
+    build(st, ed);
+  }
+
+  explicit SegmentTreeStoreSon(ptr_t st, ptr_t ed) : st(st), ed(ed) {
+    data.reserve((ed - st) * 2 - 1);
+    build(st, ed);
   }
 
+  explicit SegmentTreeStoreSon(const std::vector<T> &arr)
+      : st(0), ed(static_cast<ptr_t>(arr.size())) {
+    data.reserve(arr.size() * 2 - 1);
+    init(0, arr.size(), arr);
+  }
+};
+
+template <class SegmentBase> struct SegmentTree : private SegmentBase {
+  using Monoid = typename SegmentBase::Monoid;
+  using ptr_t = typename SegmentBase::ptr_t;
+  using T = typename Monoid::value_type;
+  static constexpr ptr_t null = SegmentBase::null;
+
+private:
   void point_set(ptr_t node, ptr_t l, ptr_t r, ptr_t pos, const T &val) {
     if (r - l == 1)
-      data[node].value = val;
+      SegmentBase::get_value(node) = val;
     else {
       ptr_t mid = l + ((r - l) >> 1);
       if (pos < mid)
-        point_set(data[node].left, l, mid, pos, val);
+        point_set(SegmentBase::get_lc(node), l, mid, pos, val);
       else
-        point_set(data[node].right, mid, r, pos, val);
-      pushup(node);
+        point_set(SegmentBase::get_rc(node), mid, r, pos, val);
+      SegmentBase::pushup(node);
     }
   }
 
   void point_update(ptr_t node, ptr_t l, ptr_t r, ptr_t pos, const T &val) {
     if (r - l == 1)
-      data[node].value = Monoid::operation(data[node].value, val);
+      SegmentBase::get_value(node) =
+          Monoid::operation(SegmentBase::get_value(node), val);
     else {
       ptr_t mid = l + ((r - l) >> 1);
       if (pos < mid)
-        point_update(data[node].left, l, mid, pos, val);
+        point_update(SegmentBase::get_lc(node), l, mid, pos, val);
       else
-        point_update(data[node].right, mid, r, pos, val);
-      pushup(node);
+        point_update(SegmentBase::get_rc(node), mid, r, pos, val);
+      SegmentBase::pushup(node);
     }
   }
 
   T point_query(ptr_t node, ptr_t l, ptr_t r, ptr_t pos) const {
     if (r - l == 1)
-      return data[node].value;
+      return SegmentBase::get_value(node);
     ptr_t mid = l + ((r - l) >> 1);
     if (pos < mid)
-      return point_query(data[node].left, l, mid, pos);
+      return point_query(SegmentBase::get_lc(node), l, mid, pos);
     else
-      return point_query(data[node].right, mid, r, pos);
+      return point_query(SegmentBase::get_rc(node), mid, r, pos);
   }
 
   T range_query(ptr_t node, ptr_t l, ptr_t r, ptr_t ql, ptr_t qr) const {
     if (ql >= r || qr <= l)
       return Monoid::identity();
     if (ql <= l && r <= qr)
-      return data[node].value;
+      return SegmentBase::get_value(node);
     ptr_t mid = l + ((r - l) >> 1);
-    T left_res = range_query(data[node].left, l, mid, ql, qr);
-    T right_res = range_query(data[node].right, mid, r, ql, qr);
+    T left_res = range_query(SegmentBase::get_lc(node), l, mid, ql, qr);
+    T right_res = range_query(SegmentBase::get_rc(node), mid, r, ql, qr);
     return Monoid::operation(left_res, right_res);
   }
 
@@ -136,33 +148,30 @@ template <typename Monoid, typename ptr_t = size_t> struct SegmentTree {
    * @brief Constructs a SegmentTree with given size
    * @param size The size of the array
    */
-  explicit SegmentTree(ptr_t size) : tl(0), tr(size) { build(tl, tr); }
+  explicit SegmentTree(ptr_t size) : SegmentBase(size) {}
 
   /**
    * @brief Constructs a SegmentTree for the range [left, right)
    * @param left The left index (inclusive)
    * @param right The right index (exclusive)
    */
-  explicit SegmentTree(ptr_t left, ptr_t right) : tl(left), tr(right) { build(tl, tr); }
+  explicit SegmentTree(ptr_t left, ptr_t right) : SegmentBase(left, right) {}
 
   /**
    * @brief Constructs a SegmentTree from an initial array
    * @param arr Initial array of elements
    */
-  explicit SegmentTree(const std::vector<T> &arr)
-      : tl(0), tr(static_cast<ptr_t>(arr.size())) {
-    build(arr);
-  }
+  explicit SegmentTree(const std::vector<T> &arr) : SegmentBase(arr) {}
 
   /**
    * @brief Sets the value at position pos to val
    * @param pos The position to update
    * @param val The new value
    */
   void point_set(ptr_t pos, const T &val) {
-    if (pos < tl || pos >= tr)
+    if (pos < get_st() || pos >= get_ed())
       throw std::out_of_range("SegmentTree::point_set: position out of range");
-    point_set(0, tl, tr, pos, val);
+    point_set(0, get_st(), get_ed(), pos, val);
   }
 
   /**
@@ -171,9 +180,9 @@ template <typename Monoid, typename ptr_t = size_t> struct SegmentTree {
    * @param val The value to combine
    */
   void point_update(ptr_t pos, const T &val) {
-    if (pos < tl || pos >= tr)
+    if (pos < get_st() || pos >= get_ed())
       throw std::out_of_range("SegmentTree::point_update: position out of range");
-    point_update(0, tl, tr, pos, val);
+    point_update(0, get_st(), get_ed(), pos, val);
   }
 
   /**
@@ -182,9 +191,9 @@ template <typename Monoid, typename ptr_t = size_t> struct SegmentTree {
    * @return The value at position pos
    */
   T point_query(ptr_t pos) const {
-    if (pos < tl || pos >= tr)
+    if (pos < get_st() || pos >= get_ed())
       throw std::out_of_range("SegmentTree::point_query: position out of range");
-    return point_query(0, tl, tr, pos);
+    return point_query(0, get_st(), get_ed(), pos);
   }
 
   /**
@@ -194,13 +203,13 @@ template <typename Monoid, typename ptr_t = size_t> struct SegmentTree {
    * @return The result of the monoid operation over the range
    */
   T range_query(ptr_t left, ptr_t right) const {
-    if (left < tl || right > tr || left > right)
+    if (left < get_st() || right > get_ed() || left > right)
       throw std::out_of_range("SegmentTree::range_query: range out of bounds");
-    return range_query(0, tl, tr, left, right);
+    return range_query(0, get_st(), get_ed(), left, right);
   }
 
-  ptr_t left() const { return tl; }
-  ptr_t right() const { return tr; }
+  ptr_t get_st() const { return SegmentBase::get_st(); }
+  ptr_t get_ed() const { return SegmentBase::get_ed(); }
 };
 } // namespace weilycoder