CSES1736 WA&TLE

// Problem: Polynomial Queries
// Contest: CSES - CSES Problem Set
// URL: https://cses.fi/problemset/task/1736/
// Memory Limit: 512 MB
// Time Limit: 1000 ms
//
// Powered by CP Editor (https://cpeditor.org)

#include <assert.h>
#include <bits/stdc++.h>
using namespace std;
#define dbg(...) logger(#__VA_ARGS__, __VA_ARGS__)
template <typename... Args> void logger(string vars, Args &&... values)
{
    cerr << vars << " = ";
    string delim = "";
    (..., (cerr << delim << values, delim = ", "));
    cerr << endl;
}

namespace atcoder
{

template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S), F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
    int ceil_pow2(int n)
    {
        int x = 0;
        while ((1U << x) < (unsigned int) (n))
            x++;
        return x;
    }

  public:
    lazy_segtree() : lazy_segtree(0) {}
    explicit lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
    explicit lazy_segtree(const std::vector<S> &v) : _n(int(v.size()))
    {
        log = ceil_pow2(_n);
        size = 1 << log;
        d = std::vector<S>(2 * size, e());
        lz = std::vector<F>(size, id());
        for (int i = 0; i < _n; i++)
            d[size + i] = v[i];
        for (int i = size - 1; i >= 1; i--) {
            update(i);
        }
    }

    void set(int p, S x)
    {
        assert(0 <= p && p < _n);
        p += size;
        for (int i = log; i >= 1; i--)
            push(p >> i);
        d[p] = x;
        for (int i = 1; i <= log; i++)
            update(p >> i);
    }

    S get(int p)
    {
        assert(0 <= p && p < _n);
        p += size;
        for (int i = log; i >= 1; i--)
            push(p >> i);
        return d[p];
    }

    S prod(int l, int r)
    {
        assert(0 <= l && l <= r && r <= _n);
        if (l == r)
            return e();

        l += size;
        r += size;

        for (int i = log; i >= 1; i--) {
            if (((l >> i) << i) != l)
                push(l >> i);
            if (((r >> i) << i) != r)
                push((r - 1) >> i);
        }

        S sml = e(), smr = e();
        while (l < r) {
            if (l & 1)
                sml = op(sml, d[l++]);
            if (r & 1)
                smr = op(d[--r], smr);
            l >>= 1;
            r >>= 1;
        }

        return op(sml, smr);
    }

    S all_prod() { return d[1]; }

    void apply(int p, F f)
    {
        assert(0 <= p && p < _n);
        p += size;
        for (int i = log; i >= 1; i--)
            push(p >> i);
        d[p] = mapping(f, d[p]);
        for (int i = 1; i <= log; i++)
            update(p >> i);
    }
    void apply(int l, int r, F f)
    {
        assert(0 <= l && l <= r && r <= _n);
        if (l == r)
            return;

        l += size;
        r += size;

        for (int i = log; i >= 1; i--) {
            if (((l >> i) << i) != l)
                push(l >> i);
            if (((r >> i) << i) != r)
                push((r - 1) >> i);
        }

        {
            int l2 = l, r2 = r;
            while (l < r) {
                if (l & 1)
                    all_apply(l++, f);
                if (r & 1)
                    all_apply(--r, f);
                l >>= 1;
                r >>= 1;
            }
            l = l2;
            r = r2;
        }

        for (int i = 1; i <= log; i++) {
            if (((l >> i) << i) != l)
                update(l >> i);
            if (((r >> i) << i) != r)
                update((r - 1) >> i);
        }
    }

    template <bool (*g)(S)> int max_right(int l)
    {
        return max_right(l, [](S x) { return g(x); });
    }
    template <class G> int max_right(int l, G g)
    {
        assert(0 <= l && l <= _n);
        assert(g(e()));
        if (l == _n)
            return _n;
        l += size;
        for (int i = log; i >= 1; i--)
            push(l >> i);
        S sm = e();
        do {
            while (l % 2 == 0)
                l >>= 1;
            if (!g(op(sm, d[l]))) {
                while (l < size) {
                    push(l);
                    l = (2 * l);
                    if (g(op(sm, d[l]))) {
                        sm = op(sm, d[l]);
                        l++;
                    }
                }
                return l - size;
            }
            sm = op(sm, d[l]);
            l++;
        } while ((l & -l) != l);
        return _n;
    }

    template <bool (*g)(S)> int min_left(int r)
    {
        return min_left(r, [](S x) { return g(x); });
    }
    template <class G> int min_left(int r, G g)
    {
        assert(0 <= r && r <= _n);
        assert(g(e()));
        if (r == 0)
            return 0;
        r += size;
        for (int i = log; i >= 1; i--)
            push((r - 1) >> i);
        S sm = e();
        do {
            r--;
            while (r > 1 && (r % 2))
                r >>= 1;
            if (!g(op(d[r], sm))) {
                while (r < size) {
                    push(r);
                    r = (2 * r + 1);
                    if (g(op(d[r], sm))) {
                        sm = op(d[r], sm);
                        r--;
                    }
                }
                return r + 1 - size;
            }
            sm = op(d[r], sm);
        } while ((r & -r) != r);
        return 0;
    }

  private:
    int _n, size, log;
    std::vector<S> d;
    std::vector<F> lz;

    void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
    void all_apply(int k, F f)
    {
        d[k] = mapping(f, d[k]);
        if (k < size)
            lz[k] = composition(f, lz[k]);
    }
    void push(int k)
    {
        all_apply(2 * k, lz[k]);
        all_apply(2 * k + 1, lz[k]);
        lz[k] = id();
    }
};

} // namespace atcoder

template <class T> inline auto vv(int m) { return vector<vector<T>>(m, vector<T>(m)); }
template <class T> inline auto vv(int m, int n) { return vector<vector<T>>(m, vector<T>(n)); }
template <class T, T init> inline auto vv(int m) { return vector<vector<T>>(m, vector<T>(m, init)); }
template <class T, T init> inline auto vv(int m, int n) { return vector<vector<T>>(m, vector<T>(n, init)); }

template <class T> using mpq = priority_queue<T, vector<T>, greater<T>>;

using ll = long long;
using pii = pair<int, int>;
using vl = vector<ll>;
using vi = vector<int>;
using atcoder::lazy_segtree;
using a3l = array<ll, 3>;

struct S {
    ll l, r, sum;
};
S e() { return {0, 0, 0}; }
S op(S a, S b) { return {min(a.l, b.l), max(a.r, b.r), a.sum + b.sum}; }
struct F {
    // op: [beg, end) and delta
    vector<a3l> ops;
};
S mapping(F f, S x)
{
    for (auto [beg, end, delta] : f.ops) {
        if (end <= x.l)
            continue;
        if (beg > x.r)
            break;
        // ll a = max(x.l, beg + 1) - beg, b = min(x.r - 1, end) - beg;
        ll a = max(x.l, beg) - beg + 1, b = min(x.r, end) - beg;
        x.sum += (a + b) * (b - a + 1) * delta / 2;
    }
    return x;
}
F compose(F f, F g)
{
    F ret;
    int i1, i2;
    for (i1 = 0, i2 = 0; i1 < f.ops.size() && i2 < g.ops.size();) {
        auto [fbeg, fend, fdelta] = f.ops[i1];
        auto [gbeg, gend, gdelta] = g.ops[i2];
        if (fend <= gbeg)
            ret.ops.push_back(f.ops[i1++]);
        else if (gend <= fbeg)
            ret.ops.push_back(g.ops[i2++]);
        else {
            ll dt = fdelta + gdelta;
            ll a = max(fbeg, gbeg);
            ll b = min(fend, gend);
            if (fend == gend)
                ++i1, ++i2;
            else if (fend < gend)
                ++i1;
            else
                ++i2;
            ret.ops.push_back(a3l{a, b, dt});
        }
    }
    while (i1 < f.ops.size())
        ret.ops.push_back(f.ops[i1++]);
    while (i2 < g.ops.size())
        ret.ops.push_back(g.ops[i2++]);
    return ret;
}
F id() { return {}; }

int main(int argc, char **argv)
{
    int n, q;
    cin >> n >> q;
    vector<ll> acc(n + 1);
    vector<ll> arr(n);
    for (auto &x : arr)
        cin >> x;
    for (int i = 0; i < n; ++i)
        acc[i + 1] = acc[i] + arr[i];
    vector<S> v(n);
    for (int i = 0; i < n; ++i)
        v[i] = {i, i + 1, 0};
    lazy_segtree<S, op, e, F, mapping, compose, id> seg(v);
    for (int i = 0; i < q; ++i) {
        int op, a, b;
        cin >> op >> a >> b;
        if (op == 1) {
            seg.apply(a - 1, b, F{vector<a3l>{a3l{a - 1, b, 1}}});
        } else {
            cout << acc[b] - acc[a - 1] + seg.prod(a - 1, b).sum << endl;
        }
    }
    return 0;
};