Update LazySegmentTree.cpp

Author: Rotzen823

DataStructure/SegmentTree/LazySegmentTree.cpp

@@ -9,77 +9,68 @@
 
 template <class T>
 class LazySegmentTree {
- private:
-  int n;
-  vector<T> A, st, lazy;
+    private:
+    int n;
+    const T neutral = 0; //Cambiar segun la operacion
+    vector<T> A, st, lazy;
 
-  inline int l(int p) { return (p << 1) + 1; }  // ir al hijo izquierdo
-  inline int r(int p) { return (p << 1) + 2; }  // ir al hijo derecho
+    inline int l(int p) { return (p << 1) + 1; }  // ir al hijo izquierdo
+    inline int r(int p) { return (p << 1) + 2; }  // ir al hijo derecho
 
-  void build(int index, int start, int end) {
-    if (start == end) {
-      st[index] = A[start];
-    } else {
-      int mid = (start + end) / 2;
-      build(l(index), start, mid);
-      build(r(index), mid + 1, end);
-      st[index] = st[l(index)] + st[r(index)];
+    //Cambiar segun la operacion
+    T merge(T a, T b)
+    {
+        return a + b;
     }
-  }
 
-  // Nota: Si se utiliza para el minimo o maximo de un rango no se le agrega el (end - start + 1)
-  void propagate(int index, int start, int end) {
-    if (lazy[index] != 0) {
-      st[index] += (end - start + 1) * lazy[index];
-      if (start != end) {
-        lazy[l(index)] += lazy[index];
-        lazy[r(index)] += lazy[index];
-      }
-      lazy[index] = 0;
+    // Nota: Si se utiliza para el minimo o maximo de un rango no se le agrega el (end - start + 1)
+    void propagate(int index, int start, int end, T dif) {
+        st[index] += (end - start + 1) * dif;
+        if (start != end) {
+            lazy[l(index)] += dif;
+            lazy[r(index)] += dif;
+        }
+        lazy[index] = 0;
     }
-  }
 
-  void add(int index, int start, int end, int i, int j, T val) {
-    propagate(index, start, end);
-    if ((end < i) || (start > j))
-      return;
+    void add(int index, int start, int end, int i, int j, T val) {
+        if(lazy[index]){
+            propagate(index, start, end, lazy[index]);
+        }
+        
+        if ((end < i) || (start > j))
+            return;
 
-    if (start >= i && end <= j) {
-      st[index] += (end - start + 1) * val;
-      if (start != end) {
-        lazy[l(index)] += val;
-        lazy[r(index)] += val;
-      }
-      return;
-    }
-    int mid = (start + end) / 2;
+        if (start >= i && end <= j) {
+            propagate(index, start, end, val);
+            return;
+        }
+        int mid = (start + end) / 2;
 
-    add(l(index), start, mid, i, j, x);
-    add(r(index), mid + 1, end, i, j, x);
+        add(l(index), start, mid, i, j, val);
+        add(r(index), mid + 1, end, i, j, val);
 
-    st[index] = (st[l(index)] + st[r(index)]);
-  }
+        st[index] = merge(st[l(index)], st[r(index)]);
+    }
 
-  T query(int index, int start, int end, int i, int j) {
-    propagate(index, start, end);
-    if (end < i || start > j)
-      return 0;
-    if ((i <= start) && (end <= j))
-      return st[index];
+    T query(int index, int start, int end, int i, int j) {
+        if(lazy[index]){
+            propagate(index, start, end, lazy[index]);
+        }
 
-    int mid = (start + end) / 2;
+        if (end < i || start > j)
+            return neutral;
+        if ((i <= start) && (end <= j))
+            return st[index];
 
-    return query(l(index), start, mid, i, j) + query(r(index), mid + 1, end, i, j);
-  }
+        int mid = (start + end) / 2;
 
- public:
-  LazySegmentTree(int sz) : n(sz), st(4 * n), lazy(4 * n) {}
+        return merge(query(l(index), start, mid, i, j), query(r(index), mid + 1, end, i, j));
+    }
 
-  LazySegmentTree(const vector<T> &initialA) : LazySegmentTree(SZ(initialA)) {
-    A = initialA;
-    build(0, 0, n - 1);
-  }
-  // [i, j]
-  void add(int i, int j, T val) { add(0, 0, n - 1, i, j, val); }  // [i, j]
-  T query(int i, int j) { return query(0, 0, n - 1, i, j); }      // [i, j]
+    public:
+    LazySegmentTree(int sz) : n(sz), st(4 * n), lazy(4 * n) {}
+    // [i, j]
+    void add(int i, int j, T val) { add(0, 0, n - 1, i, j, val); }  // [i, j]
+    T query(int i, int j) { return query(0, 0, n - 1, i, j); }      // [i, j]
 };