LC2569 AC

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

using ll = long long;
using atcoder::lazy_segtree;

struct S {
    ll sum, n2sum, one[2];
};
S op(S a, S b) { return S{a.sum + b.sum, a.n2sum + b.n2sum, {a.one[0] + b.one[0], a.one[1] + b.one[1]}}; }
S e() { return {0, 0, {0, 0}}; }

struct F {
    ll op, fcnt, f0, f1;
    // 0: id
    // 1: flip / add
};
S mapping(F f, S x)
{
    switch (f.op) {
        case 0:
            return x;
        case 1:
            // add then flip
            x.sum = x.sum + f.f0 * x.one[0] + f.f1 * x.one[1];
            if (f.fcnt)
                swap(x.one[0], x.one[1]);
            return x;
    }
    return x;
}
F composition(F f, F g)
{
    // g then f
    // f(g(x))
    if (g.op == 0)
        return f;
    if (f.op == 0)
        return g;

    F ret;
    ret.op = 1;
    ret.fcnt = (f.fcnt + g.fcnt) % 2;
    ret.f0 = g.f0 + (g.fcnt == 0 ? f.f0 : f.f1);
    ret.f1 = g.f1 + (g.fcnt == 0 ? f.f1 : f.f0);
    return ret;
}
F id() { return {0, 0, 0, 0}; }

class Solution
{
  public:
    vector<long long> handleQuery(vector<int> &nums1, vector<int> &nums2, vector<vector<int>> &queries)
    {
        int n = nums1.size();
        lazy_segtree<S, op, e, F, mapping, composition, id> seg(n);
        vector<ll> ret;
        for (int i = 0; i < n; ++i)
            seg.set(i, {nums2[i], nums2[i], {1 - nums1[i], nums1[i]}});
        for (const auto &q : queries) {
            switch (q[0]) {
                case 1: {
                    int l = q[1], r = q[2] + 1;
                    seg.apply(l, r, F{1, 1, 0, 0});
                    break;
                }
                case 2:
                    seg.apply(0, n, F{1, 0, 0, q[1]});
                    break;
                case 3:
                    auto node = seg.all_prod();
                    ret.push_back(node.sum);
                    break;
            }
        }
        return ret;
    }
};