segment_tree_lazy(template).cpp

template<class T>
struct Segtree
{
#define segtre int m=(x+y)>>1,lu=2*u,ru=2*u+1
    struct data
    {
        T v;
        data() { this->v = 0; }
        data(T v) { this->v = v; }
    };

    vector<T> ara;
    vector<data> t;
    vector<T> lazy;
    int n;

    Segtree() {}
    Segtree(int n) {
        this->n = n;
        t = vector<data>(4 * n);
        lazy = vector<T>(4 * n, 0);
    }

    void Init(vector<T> vec) {
        this->ara = vec;
        Init(1, 0, n - 1);  // 0-indexed
    }
    void Update(int l, int r, T val) {
        Update(1, 0, n - 1, l, r, val);  // 0-indexed
    }
    data Query(int l, int r) {
        return Query(1, 0, n - 1, l, r);  // 0-indexed
    }
    data Combine(data a, data b) {
        data temp;
        temp.v = a.v + b.v;
        return temp;
    }
    void Init(int u, int x, int y) {
        if (x == y) {
            t[u].v = ara[x];
            return;
        }
        segtre;
        Init(lu, x, m);
        Init(ru, m + 1, y);
        t[u] = Combine(t[lu], t[ru]);
    }
    void Propagate(int u, int x, int y) {
        if (lazy[u] != 0) {
            t[u].v += (y - x + 1) * lazy[u];  // Update the current node
            if (x != y) {
                lazy[2 * u] += lazy[u];    // Mark children as lazy
                lazy[2 * u + 1] += lazy[u];
            }
            lazy[u] = 0;  // Clear the lazy value
        }
    }
    void Update(int u, int x, int y, int b, int e, T val) {
        Propagate(u, x, y);
        if (x > e || y < b) return;
        if (x >= b && y <= e) {
            lazy[u] += val;
            Propagate(u, x, y);
            return;
        }
        segtre;
        Update(lu, x, m, b, e, val);
        Update(ru, m + 1, y, b, e, val);
        t[u] = Combine(t[lu], t[ru]);
    }
    data Query(int u, int x, int y, int b, int e) {
        Propagate(u, x, y);
        if (x > e || y < b) return data();
        if (x >= b && y <= e) return t[u];
        segtre;
        data res1 = Query(lu, x, m, b, e);
        data res2 = Query(ru, m + 1, y, b, e);
        return Combine(res1, res2);
    }
};

   vector<int> array = {1, 2, 3, 4, 5};

    // Initialize segment tree
    Segtree<int> segtree(n);
    segtree.Init(array);