#1159483 (C++23) No.3507 RangeSum RangeUpdate RangeSqrt

• 問題: No.3507 RangeSum RangeUpdate RangeSqrt
• ユーザー: tassei903
• 提出日時: 2026-04-18 11:55:23
• 言語: C++23 (gcc 15.2.0 + boost 1.89.0)
• 結果: AC
• 実行時間: 214 ms / 2,000 ms
• コード長: 11,201 bytes
• コンパイル時間: 3,543 ms
• コンパイル使用メモリ: 363,044 KB
• 実行使用メモリ: 29,272 KB
• 最終ジャッジ日時: 2026-04-18 11:55:39
• 合計ジャッジ時間: 15,358 ms
• ジャッジサーバーID （参考情報）: judge3_1 / judge1_1

ファイルパターン	結果
sample	AC * 1
other	AC * 29

ソースコード

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vl vector<ll>
#define ov4(a, b, c, d, name, ...) name
#define rep3(i, a, b, c) for(ll i = (a); i < (b); i += (c))
#define rep2(i, a, b) rep3(i, a, b, 1)
#define rep1(i, n) rep2(i, 0, n)
#define rep0(n) rep1(aaaaa, n)
#define rep(...) ov4(__VA_ARGS__, rep3, rep2, rep1, rep0)(__VA_ARGS__)
#define per(i, a, b) for(ll i = (a)-1; i >= (b); i--)
#define fore(e, v) for(auto&& e : v)
#define all(a) begin(a), end(a)
#define sz(a) (int)(a.size())
#define lb(v, x) (lower_bound(all(v), x) - begin(v))
#define eb emplace_back

template<typename T, typename S> bool chmin(T& a, const S& b) { return a > b ? a = b, 1 : 0; }
template<typename T, typename S> bool chmax(T& a, const S& b) { return a < b ? a = b, 1 : 0; }
 
const int INF = 1e9 + 100;
const ll INFL = 3e18 + 100;
 
#define i128 __int128_t
 
struct _ {
   _() { cin.tie(0)->sync_with_stdio(0), cout.tie(0); }
} __;

void debug(auto ...vs) {
    ((cerr << vs << " "), ...) << endl;
}


const int mod = 998244353;
class mint {
    long long x;
public:
    mint(long long x=0) : x((x%mod+mod)%mod) {}
    mint operator-() const { 
      return mint(-x);
    }
    mint& operator+=(const mint& a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint& a) {
        if ((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const  mint& a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint& a) const {
        mint res(*this);
        return res+=a;
    }
    mint operator-(const mint& a) const {
        mint res(*this);
        return res-=a;
    }
    mint operator*(const mint& a) const {
        mint res(*this);
        return res*=a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
    // for prime mod
    mint inv() const {
        return pow(mod-2);
    }
    mint& operator/=(const mint& a) {
        return (*this) *= a.inv();
    }
    mint operator/(const mint& a) const {
        mint res(*this);
        return res/=a;
    }

    friend ostream& operator<<(ostream& os, const mint& m){
        os << m.x;
        return os;
    }
};
int ceil_pow2(int n) {
    int x = 0;
    while ((1U << x) < (unsigned int)(n)) x++;
    return x;
}
template <class S,
          S (*op)(S, S),
          S (*e)(),
          class F,
          S (*mapping)(F, S),
          F (*composition)(F, F),
          F (*id)()>
struct lazy_segtree {
  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;
    }
    void debug() {
        cout << "==================================" << endl;
        for(auto x:d)cout << x.max << " " << x.min << " " << x.len << " " << x.sum << endl;
        cout << "==================================" << endl;
    }

  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]);
            if (d[k].fail) push(k), update(k);
        }
    }
    void push(int k) {
        all_apply(2 * k, lz[k]);
        all_apply(2 * k + 1, lz[k]);
        lz[k] = id();
    }
};
uint64_t kth_root(uint64_t N, uint64_t K = 2) {
    assert(K >= 1);
    if (N <= 1 || K == 1) return N;
    if (K >= 64) return 1;
    if (N == uint64_t(-1)) --N;
    
    auto mul = [&](uint64_t x, uint64_t y) -> uint64_t {
        if (x < UINT_MAX && y < UINT_MAX) return x * y;
        if (x == uint64_t(-1) || y == uint64_t(-1)) return uint64_t(-1);
        return (x <= uint64_t(-1) / y ? x * y : uint64_t(-1));
    };
    auto power = [&](uint64_t x, uint64_t k) -> uint64_t {
        if (k == 0) return 1ULL;
        uint64_t res = 1ULL;
        while (k) {
            if (k & 1) res = mul(res, x);
            x = mul(x, x);
            k >>= 1;
        }
        return res;
    };
    
    uint64_t res;
    if (K == 2) res = sqrtl(N) - 1;
    else if (K == 3) res = cbrt(N) - 1;
    else res = pow(N, nextafter(1 / double(K), 0));
    while (power(res + 1, K) <= N) ++res;
    return res;
}


const ll inf = 1e9;
const int cntmax = 5;

struct S{
    ll max,min,len;
    ll sum;
    bool fail;
    S(ll max, ll min, ll len, ll sum, bool fail) :max(max),min(min),len(len),sum(sum),fail(0) {}
};

S op(S l, S r) {
    ll x = max(l.max,r.max), y = min(l.min,r.min);
    bool fail = (x != y);
    return S(x,y,l.len+r.len,l.sum+r.sum, fail);
}
S e() {
    return S(-inf,inf,0,0,true);
}
struct F {
    ll cnt, val;
    F(ll cnt, ll val): cnt(cnt),val(val) {}
};

// x <= X


S mapping(F f, S s) {
    if (s.fail)return s;
    if (f.val != -1)return S(f.val,f.val,s.len,f.val*s.len,false);
    if(f.cnt==0){
        s.fail = false;
        return s;
    }
    if(s.max == s.min) {
        ll zz = kth_root(s.max, 1 << f.cnt);
        return S(zz, zz, s.len, zz*s.len, false);
    }
    if(f.cnt > cntmax) {return S(1, 1, s.len, s.len, false);}
    S x = e();
    x.fail = true;
    return x;
}

F composition(F f1, F f2) {
    if(f1.val != -1)return f1;
    if(f2.val != -1)return F(0, kth_root(f2.val, 1 << f1.cnt));
    if (f1.cnt + f2.cnt > cntmax)return F(0, 1);
    return F(f1.cnt + f2.cnt,-1);
    
}

F id() {
    return F(0, -1);
}

struct S2 { 
    ll len, sum;
    bool fail = false;
};
S2 op(S2 x, S2 y) {
    return {x.len + y.len, x.sum + y.sum, false};
}
S2 e2() {
    return {0, 0, false};
}

S2 mapping(int f, S2 s) {
    if (f == -1) return s;
    else return {s.len, s.len * f, false};
}

int composition(int f1, int f2) {
    if (f1 != -1) return f1;
    return f2;
}
int id2() {
    return -1;
}

void solve() {
    int n, q;
    cin >> n >> q;
    vi a(n);rep(i, n) cin >> a[i];
    vector<S> b;
    vector<S2> c;
    rep(i, n) {
        if (a[i] == 0) {
            b.emplace_back(S{1, 1, 1, 1, false});
            c.emplace_back(S2{1, 1, false});
        }
        else {
            b.emplace_back(S{a[i], a[i], 1, a[i], false});
            c.emplace_back(S2{1, 0, false});
        }
    }
    lazy_segtree<S, op, e, F, mapping, composition, id> lst(b);
    lazy_segtree<S2, op, e2, int, mapping, composition, id2> lst2(c);

    rep(q) {
        // rep(i, n) cerr << lst.get(i).sum << " ";
        // cerr << endl;
        int t;cin >> t;
        if (t == 0) {
            int l, r; cin >> l >> r;
            cout << lst.prod(l, r).sum - lst2.prod(l, r).sum << endl;
        }
        else if (t == 1) {
            int l, r, x; cin >> l >> r >> x;
            if (x == 0) {
                lst.apply(l, r, F{0, 1});
                lst2.apply(l, r, 1);
            }
            else {
                lst.apply(l, r, F{0, x});
                lst2.apply(l, r, 0);
            }
        }
        else {
            int l, r;cin >> l >> r;
            lst.apply(l, r, F{1, -1});
        }
    }
}

int main(){
    int T = 1;
    // int T;cin >> T;
    while(T--) {

        solve();
    }
    
}