#1158504 (C++17) No.3507 RangeSum RangeUpdate RangeSqrt

• 問題: No.3507 RangeSum RangeUpdate RangeSqrt
• ユーザー: dyktr_06
• 提出日時: 2026-04-17 23:45:23
• 言語: C++17 (gcc 15.2.0 + boost 1.89.0)
• 結果: WA
• 実行時間: -
• コード長: 17,466 bytes
• コンパイル時間: 2,738 ms
• コンパイル使用メモリ: 243,804 KB
• 実行使用メモリ: 44,068 KB
• 最終ジャッジ日時: 2026-04-17 23:46:02
• 合計ジャッジ時間: 21,918 ms
• ジャッジサーバーID （参考情報）: judge3_0 / judge1_1

ファイルパターン	結果
sample	AC * 1
other	AC * 18 WA * 11

ソースコード

#include <bits/stdc++.h>

using namespace std;

#define overload4(_1, _2, _3, _4, name, ...) name
#define rep1(n) for(int i = 0; i < (int)(n); ++i)
#define rep2(i, n) for(int i = 0; i < (int)(n); ++i)
#define rep3(i, a, b) for(int i = (a); i < (int)(b); ++i)
#define rep4(i, a, b, c) for(int i = (a); i < (int)(b); i += (c))
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)

#define rrep(i,n) for(int i = (int)(n) - 1; i >= 0; --i)
#define ALL(a) (a).begin(), (a).end()
#define Sort(a) (sort((a).begin(), (a).end()))
#define RSort(a) (sort((a).rbegin(), (a).rend()))
#define UNIQUE(a) (a.erase(unique((a).begin(), (a).end()), (a).end()))

using i64 = int64_t;
using i128 = __int128_t;

using ll = long long;
using ul = unsigned long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vll = vector<long long>;
using vull = vector<unsigned long long>;
using vc = vector<char>;
using vst = vector<string>;
using vd = vector<double>;
using vld = vector<long double>;
using P = pair<long long, long long>;

template<class T> long long sum(const T &a){ return accumulate(a.begin(), a.end(), 0LL); }
template<class T> auto min(const T &a){ return *min_element(a.begin(), a.end()); }
template<class T> auto max(const T &a){ return *max_element(a.begin(), a.end()); }

const long long MINF = 0x7fffffffffff;
const long long INF = 0x1fffffffffffffff;
const long long MOD = 998244353;
const long double EPS = 1e-9;
const long double PI = acos(-1);

template<class T> inline bool chmax(T &a, T b) { if(a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if(a > b) { a = b; return 1; } return 0; }

template<typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p){ is >> p.first >> p.second; return is; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &p){ os << "(" << p.first << ", " << p.second << ")"; return os; }
template<typename T> istream &operator>>(istream &is, vector<T> &v){ for(T &in : v) is >> in; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &v){ for(int i = 0; i < (int) v.size(); ++i){ os << v[i] << (i + 1 != (int) v.size() ? " " : ""); } return os; }
template <typename T, typename S> ostream &operator<<(ostream &os, const map<T, S> &mp){ for(auto &[key, val] : mp){ os << key << ":" << val << " "; } return os; }
template <typename T> ostream &operator<<(ostream &os, const set<T> &st){ auto itr = st.begin(); for(int i = 0; i < (int) st.size(); ++i){ os << *itr << (i + 1 != (int) st.size() ? " " : ""); itr++; } return os; }
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &st){ auto itr = st.begin(); for(int i = 0; i < (int) st.size(); ++i){ os << *itr << (i + 1 != (int) st.size() ? " " : ""); itr++; } return os; }
template <typename T> ostream &operator<<(ostream &os, queue<T> q){ while(q.size()){ os << q.front() << " "; q.pop(); } return os; }
template <typename T> ostream &operator<<(ostream &os, deque<T> q){ while(q.size()){ os << q.front() << " "; q.pop_front(); } return os; }
template <typename T> ostream &operator<<(ostream &os, stack<T> st){ while(st.size()){ os << st.top() << " "; st.pop(); } return os; }
template <class T, class Container, class Compare> ostream &operator<<(ostream &os, priority_queue<T, Container, Compare> pq){ while(pq.size()){ os << pq.top() << " "; pq.pop(); } return os; }

template<class T, class U>
void inGraph(vector<vector<T>> &G, U n, U m, bool directed = true, bool zero_index = true){
    G.resize(n);
    for(int i = 0; i < m; i++){
        int a, b;
        cin >> a >> b;
        if(!zero_index) a--, b--;
        G[a].push_back(b);
        if(!directed) G[b].push_back(a);
    }
}

template <typename T>
long long binary_search(long long ok, long long ng, T check){
    while(abs(ok - ng) > 1){
        long long mid = (ok + ng) / 2;
        if(check(mid)) ok = mid;
        else ng = mid;
    }
    return ok;
}

template <typename T>
long double binary_search_real(long double ok, long double ng, T check, int iter = 100){
    for(int i = 0; i < iter; ++i){
        long double mid = (ok + ng) / 2;
        if(check(mid)) ok = mid;
        else ng = mid;
    }
    return ok;
}

long long trisum(long long a, long long b){
    if(a > b) return 0;
    long long res = ((b - a + 1) * (a + b)) / 2;
    return res;
}

template <typename T>
T intpow(T x, int n){
    T ret = 1;
    while(n > 0) {
        if(n & 1) (ret *= x);
        (x *= x);
        n >>= 1;
    }
    return ret;
}

template <typename T>
T getDivision(T a, T b){
    if(b == 0) return -1;
    if(a >= 0 && b > 0){
        return a / b;
    } else if(a < 0 && b > 0){
        return a / b - (a % b != 0);
    } else if(a >= 0 && b < 0){
        return a / b;
    } else{
        return a / b + (a % b != 0);
    }
}

template <typename T>
T getReminder(T a, T b){
    if(b == 0) return -1;
    if(a >= 0 && b > 0){
        return a % b;
    } else if(a < 0 && b > 0){
        return ((a % b) + b) % b;
    } else if(a >= 0 && b < 0){
        return a % b;
    } else{
        return (abs(b) - abs(a % b)) % b;
    }
}

template<class T, class U> inline T vin(T &vec, U n) { vec.resize(n); for(int i = 0; i < (int) n; ++i) cin >> vec[i]; return vec; }
template<class T> inline void vout(T vec, string s = "\n"){ for(auto x : vec) cout << x << s; }
template<class... T> void in(T&... a){ (cin >> ... >> a); }
void out(){ cout << '\n'; }
template<class T, class... Ts> void out(const T &a, const Ts&... b){ cout << a; ((cout << ' ' << b), ...); cout << '\n'; }
void fout(){ cout << endl; }
template<class T, class... Ts> void fout(const T &a, const Ts&... b){ cout << a; ((cout << ' ' << b), ...); cout << endl; }
void debug(){ cerr << '\n'; }
template<class T, class... Ts> void debug(const T &a, const Ts&... b){ cerr << a; ((cout << ' ' << b), ...); cerr << '\n'; }

template<typename T, T INF>
struct SegmentTreeBeats{
    int n, n0;
    vector<T> max_v, smax_v, max_c;
    vector<T> min_v, smin_v, min_c;
    vector<T> sum;
    vector<T> len, ladd, lval;

    void update_node_max(int k, T x) {
        sum[k] += (x - max_v[k]) * max_c[k];

        if(max_v[k] == min_v[k]){
            max_v[k] = min_v[k] = x;
        }else if(max_v[k] == smin_v[k]){
            max_v[k] = smin_v[k] = x;
        }else{
            max_v[k] = x;
        }

        if(lval[k] != INF && x < lval[k]){
            lval[k] = x;
        }
    }

    void update_node_min(int k, T x) {
        sum[k] += (x - min_v[k]) * min_c[k];

        if(max_v[k] == min_v[k]){
            max_v[k] = min_v[k] = x;
        }else if(smax_v[k] == min_v[k]){
            min_v[k] = smax_v[k] = x;
        }else{
            min_v[k] = x;
        }

        if(lval[k] != INF && lval[k] < x){
            lval[k] = x;
        }
    }

    void push(int k){
        if(n0 - 1 <= k) return;

        if(lval[k] != INF){
            updateall(2 * k + 1, lval[k]);
            updateall(2 * k + 2, lval[k]);
            lval[k] = INF;
            return;
        }

        if(ladd[k] != 0){
            addall(2 * k + 1, ladd[k]);
            addall(2 * k + 2, ladd[k]);
            ladd[k] = 0;
        }

        if(max_v[k] < max_v[2 * k + 1]){
            update_node_max(2 * k + 1, max_v[k]);
        }
        if(min_v[2 * k + 1] < min_v[k]){
            update_node_min(2 * k + 1, min_v[k]);
        }

        if(max_v[k] < max_v[2 * k + 2]){
            update_node_max(2 * k + 2, max_v[k]);
        }
        if(min_v[2 * k + 2] < min_v[k]){
            update_node_min(2 * k + 2, min_v[k]);
        }
    }

    void update(int k){
        sum[k] = sum[2 * k + 1] + sum[2 * k + 2];

        if(max_v[2 * k + 1] < max_v[2 * k + 2]){
            max_v[k] = max_v[2 * k + 2];
            max_c[k] = max_c[2 * k + 2];
            smax_v[k] = max(max_v[2 * k + 1], smax_v[2 * k + 2]);
        }else if(max_v[2 * k + 1] > max_v[2 * k + 2]){
            max_v[k] = max_v[2 * k + 1];
            max_c[k] = max_c[2 * k + 1];
            smax_v[k] = max(smax_v[2 * k + 1], max_v[2 * k + 2]);
        }else{
            max_v[k] = max_v[2 * k + 1];
            max_c[k] = max_c[2 * k + 1] + max_c[2 * k + 2];
            smax_v[k] = max(smax_v[2 * k + 1], smax_v[2 * k + 2]);
        }

        if(min_v[2 * k + 1] < min_v[2 * k + 2]){
            min_v[k] = min_v[2 * k + 1];
            min_c[k] = min_c[2 * k + 1];
            smin_v[k] = min(smin_v[2 * k + 1], min_v[2 * k + 2]);
        }else if(min_v[2 * k + 1] > min_v[2 * k + 2]){
            min_v[k] = min_v[2 * k + 2];
            min_c[k] = min_c[2 * k + 2];
            smin_v[k] = min(min_v[2 * k + 1], smin_v[2 * k + 2]);
        }else{
            min_v[k] = min_v[2 * k + 1];
            min_c[k] = min_c[2 * k + 1] + min_c[2 * k + 2];
            smin_v[k] = min(smin_v[2 * k + 1], smin_v[2 * k + 2]);
        }
    }

    void _query_chmin(T x, int a, int b, int k, int l, int r) {
        if(b <= l || r <= a || max_v[k] <= x){
            return;
        }
        if(a <= l && r <= b && smax_v[k] < x){
            update_node_max(k, x);
            return;
        }

        push(k);
        _query_chmin(x, a, b, 2 * k + 1, l, (l + r) / 2);
        _query_chmin(x, a, b, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }

    void _query_chmax(T x, int a, int b, int k, int l, int r) {
        if(b <= l || r <= a || x <= min_v[k]){
            return;
        }
        if(a <= l && r <= b && x < smin_v[k]){
            update_node_min(k, x);
            return;
        }

        push(k);
        _query_chmax(x, a, b, 2 * k + 1, l, (l + r) / 2);
        _query_chmax(x, a, b, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }

    void addall(int k, T x) {
        max_v[k] += x;
        if(smax_v[k] != -INF) smax_v[k] += x;
        min_v[k] += x;
        if(smin_v[k] != INF) smin_v[k] += x;

        sum[k] += len[k] * x;
        if(lval[k] != INF){
            lval[k] += x;
        }else{
            ladd[k] += x;
        }
    }

    void updateall(int k, T x) {
        max_v[k] = x; smax_v[k] = -INF;
        min_v[k] = x; smin_v[k] = INF;
        max_c[k] = min_c[k] = len[k];

        sum[k] = x * len[k];
        lval[k] = x; ladd[k] = 0;
    }

    void _query_add(T x, int a, int b, int k, int l, int r) {
        if(b <= l || r <= a){
            return;
        }
        if(a <= l && r <= b){
            addall(k, x);
            return;
        }

        push(k);
        _query_add(x, a, b, 2 * k + 1, l, (l + r) / 2);
        _query_add(x, a, b, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }

    void _query_update(T x, int a, int b, int k, int l, int r) {
        if(b <= l || r <= a){
            return;
        }
        if(a <= l && r <= b){
            updateall(k, x);
            return;
        }

        push(k);
        _query_update(x, a, b, 2 * k + 1, l, (l + r) / 2);
        _query_update(x, a, b, 2 * k + 2, (l + r) / 2, r);
        update(k);
    }

    T _query_max(int a, int b, int k, int l, int r) {
        if(b <= l || r <= a){
            return -INF;
        }
        if(a <= l && r <= b){
            return max_v[k];
        }
        push(k);
        T lv = _query_max(a, b, 2 * k + 1, l, (l + r) / 2);
        T rv = _query_max(a, b, 2 * k + 2, (l + r) / 2, r);
        return max(lv, rv);
    }

    T _query_min(int a, int b, int k, int l, int r) {
        if(b <= l || r <= a){
            return INF;
        }
        if(a <= l && r <= b){
            return min_v[k];
        }
        push(k);
        T lv = _query_min(a, b, 2 * k + 1, l, (l + r) / 2);
        T rv = _query_min(a, b, 2 * k + 2, (l + r) / 2, r);
        return min(lv, rv);
    }

    T _query_sum(int a, int b, int k, int l, int r) {
        if(b <= l || r <= a){
            return 0;
        }
        if(a <= l && r <= b){
            return sum[k];
        }
        push(k);
        T lv = _query_sum(a, b, 2 * k + 1, l, (l + r) / 2);
        T rv = _query_sum(a, b, 2 * k + 2, (l + r) / 2, r);
        return lv + rv;
    }

public:
    SegmentTreeBeats(int n) : n(n){
        vector<T> a;
        init(n, a);
    }

    SegmentTreeBeats(int n, vector<T> &a) : n(n){
        init(n, a);
    }

    void init(int n, vector<T> &a){
        max_v.assign(4 * n, 0), smax_v.assign(4 * n, 0), max_c.assign(4 * n, 0);
        min_v.assign(4 * n, 0), smin_v.assign(4 * n, 0), min_c.assign(4 * n, 0);
        sum.assign(4 * n, 0);
        len.assign(4 * n, 0), ladd.assign(4 * n, 0); lval.assign(4 * n, 0);

        n0 = 1;
        while(n0 < n) n0 <<= 1;

        for(int i = 0; i < 2 * n0; ++i) ladd[i] = 0, lval[i] = INF;
        len[0] = n0;
        for(int i = 0; i < n0 - 1; ++i) len[2 * i + 1] = len[2 * i + 2] = (len[i] >> 1);

        for(int i = 0; i < n; ++i){
            max_v[n0 - 1 + i] = min_v[n0 - 1 + i] = sum[n0 - 1 + i] = (!a.empty() ? a[i] : 0);
            smax_v[n0 - 1 + i] = -INF;
            smin_v[n0 - 1 + i] = INF;
            max_c[n0 - 1 + i] = min_c[n0 - 1 + i] = 1;
        }

        for(int i = n; i < n0; ++i){
            max_v[n0 - 1 + i] = smax_v[n0 - 1 + i] = -INF;
            min_v[n0 - 1 + i] = smin_v[n0 - 1 + i] = INF;
            max_c[n0 - 1 + i] = min_c[n0 - 1 + i] = 0;
        }
        for(int i = n0 - 2; i >= 0; --i){
            update(i);
        }
    }

    // range minimize query
    void query_chmin(int a, int b, T x){
        _query_chmin(x, a, b, 0, 0, n0);
    }

    // range maximize query
    void query_chmax(int a, int b, T x){
        _query_chmax(x, a, b, 0, 0, n0);
    }

    // range add query
    void query_add(int a, int b, T x){
        _query_add(x, a, b, 0, 0, n0);
    }

    // range update query
    void query_update(int a, int b, T x){
        _query_update(x, a, b, 0, 0, n0);
    }

    // range minimum query
    T query_max(int a, int b){
        return _query_max(a, b, 0, 0, n0);
    }

    // range maximum query
    T query_min(int a, int b){
        return _query_min(a, b, 0, 0, n0);
    }

    // range sum query
    T query_sum(int a, int b){
        return _query_sum(a, b, 0, 0, n0);
    }

    T get(int x){
        return _query_sum(x, x + 1, 0, 0, n0);
    }
};

unsigned long long kthRoot(unsigned long long a, unsigned long long k){
    unsigned long long tmp = powl(a, (long double) 1 / (long double) k);
    unsigned long long res = 0;
    vector<unsigned long long> border = {tmp - 1, tmp, tmp + 1};
    for(auto x : border){
        if(x == 0) continue;
        unsigned long long curr = a;
        for(int i = 0; i < (int) k; i++){
            curr /= x;
        }
        if(curr >= 1) res = max(res, x);
    }
    return res;
}

ll T;

void input(){
    in(T);
}

void solve(){
    // https://atcoder.jp/contests/abc256/tasks/abc256_h
    ll n, q; in(n, q);
    vll a(n); in(a);
    SegmentTreeBeats<ll, INF> seg(n, a);
    set<P> s; // [l, r]
    s.emplace(-INF, -INF);
    s.emplace(INF, INF);
    rep(i, n){
        s.emplace(i, i);
    }
    while(q--){
        ll t, l, r; in(t, l, r);
        if(t == 0){
            out(seg.query_sum(l, r));
        }else if(t == 1){
            ll y; in(y);
            auto iter = s.lower_bound({l, l});
            iter--;
            if((*iter).first != -INF && l <= (*iter).second){
                auto [nl, nr] = *iter; 
                s.erase(iter);
                s.emplace(nl, l - 1);
                s.emplace(l, nr);
            }
            ll now = l;
            vector<P> deleted;
            iter = s.lower_bound({now, now});
            while(true){
                auto [nl, nr] = *iter;
                if(r <= nl) break;
                if(r <= nr){
                    deleted.push_back(*iter);
                    s.emplace(r, nr);
                    break;
                }
                deleted.push_back(*iter);
                now = nr + 1;
                iter++;
            }
            for(auto [nl, nr] : deleted){
                s.erase({nl, nr});
            }
            seg.query_update(l, r, y);
            s.emplace(l, r - 1);
        }else{
            auto iter = s.lower_bound({l, l});
            iter--;
            if((*iter).first != -INF && l <= (*iter).second){
                auto [nl, nr] = *iter; 
                s.erase(iter);
                s.emplace(nl, l - 1);
                s.emplace(l, nr);
            }
            ll now = l;

            vector<P> deleted;
            iter = s.lower_bound({now, now});
            while(true){
                auto [nl, nr] = *iter;
                if(r <= nl) break;
                if(r <= nr){
                    deleted.push_back(*iter);
                    s.emplace(r, nr);
                    ll v = seg.get(nl);
                    if(v >= 4){
                        s.emplace(nl, r - 1);
                    }
                    seg.query_update(nl, r, kthRoot(v, 2));
                    break;
                }
                ll v = seg.get(nl);
                if(v <= 4){
                    deleted.push_back(*iter);
                }
                seg.query_update(nl, nr + 1, kthRoot(v, 2));
                now = nr + 1;
                iter++;
            }
            for(auto [nl, nr] : deleted){
                s.erase({nl, nr});
            }
        }
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(20);

    T = 1;
    // input();
    while(T--) solve();
}