lazy_segtree

struct segtree {
    struct node {
        int val;
        int prop;

        node() {
            val = 0;
            prop = 0;
        }
    };

    int size;
    vector<node> tree;

    segtree(int n) {
        size = 1;
        while (size < n) {
            size *= 2;
        }
        tree.resize(2 * size - 1);
    }

    void propagate(int x) {
        if (x > size - 2) {
            return;
        } else {
            tree[2 * x + 1].prop += tree[x].prop;
            tree[2 * x + 2].prop += tree[x].prop;
            tree[2 * x + 1].val += tree[x].prop;
            tree[2 * x + 2].val += tree[x].prop;

            tree[x].prop = 0;
        }
    }

    void set(int l, int r, int v, int x, int lx, int rx) {
        if (rx <= l || r <= lx) {
            return;
        }
        propagate(x);
        if (l <= lx && rx <= r) {
            tree[x].prop += v;
            tree[x].val += v;
            return;
        }
        int m = (lx + rx) / 2;
        set(l, r, v, 2 * x + 1, lx, m);
        set(l, r, v, 2 * x + 2, m, rx);
        tree[x].val = min(tree[2 * x + 1].val, tree[2 * x + 2].val);
    }

    void set(int l, int r, int v) {
        set(l, r, v, 0, 0, size);
    }

    int get(int l, int r, int x, int lx, int rx) {
        if (rx <= l || r <= lx) {
            return INT64_MAX;
        }
        propagate(x);
        if (l <= lx && rx <= r) {
            return tree[x].val;
        }
        int m = (lx + rx) / 2;
        int v1 = get(l, r, 2 * x + 1, lx, m);
        int v2 = get(l, r, 2 * x + 2, m, rx);
        return min(v1, v2);
    }

    int get(int l, int r) {
        return get(l, r, 0, 0, size);
    }
};