LC biweek 98 T4 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 atcoder::lazy_segtree;
using ll = long long;

struct S {
    ll sum, n2sum, one[2];
};
struct F;
F id();
struct F {
    ll op, fcnt, f0, f1;
    // op 0 for element operation
    // op 1 for n1 range flip
    // op 2 for n2 range add
    // op 3 for compound operators
    S map(S r) {
        switch(op) {
            case 1:
                swap(r.one[0], r.one[1]);
                return r;
            case 2:
                r.sum += r.one[1] * f1;
                return r;
            case 3:
                r.sum += r.one[0] * f0 + r.one[1] * f1;
                if (fcnt % 2) swap(r.one[0], r.one[1]);
                return r;
        }
        return r;
    }
    F compose(F f) {
        if (this->op == 0) return f;
        if (f.op == 0) return *this;
        if (f.op == 1 && this->op == 1) return id();
        if (f.op == 2 && this->op == 2) {
            this->f1 += f.f1;
            return *this;
        }
        if (this->op == 1 && f.op == 2) return {3, 1, f.f1, f.f0};
        if (this->op == 2 && f.op == 1) return {3, 1, f0, f1};

        F ret;
        ret.op = 3;
        ret.fcnt = (this->fcnt + f.fcnt) % 2;
        ret.f0 = this->f0 + (fcnt % 2 ? f.f1 : f.f0);
        ret.f1 = this->f1 + (fcnt % 2 ? f.f0 : f.f1);
        return ret;
    }
};
S e() { return {0, 0, {0, 0}}; }
S op(S a, S b) { return {a.sum + b.sum, a.n2sum + b.n2sum, {a.one[0] + b.one[0], a.one[1] + b.one[1]}}; }
S mapping(F f, S r) { return f.map(r); };
F id() { return {0, 0, 0, 0}; };
F composition(F f, F g) {
    // g then f
    return g.compose(f);
};

class Solution {
public:
    vector<long long> handleQuery(vector<int>& ns1, vector<int>& ns2, vector<vector<int>>& qs) {
        int n = ns1.size();
        lazy_segtree<S, op, e, F, mapping, composition, id> seg(n);
        for (int i = 0; i < n; ++i) {
            seg.set(i, {ns2[i], ns2[i], {1 - ns1[i], ns1[i]}});
        }
        vector<ll> ret;

        for (const auto& q: qs) {
            switch (q[0]) {
                case 1:
                    seg.apply(q[1], q[2] + 1, F{1, 1, 0, 0});
                    break;
                case 2:
                    seg.apply(0, n, F{2, 0, 0, q[1]});
                    break;
                case 3:
                    auto ans = seg.all_prod();
                    ret.push_back(ans.sum);
                    break;
            }
        }
        return ret;
    }
};