結果

問題 No.8121 [Deleted]
コンテスト
ユーザー Nachia
提出日時 2025-04-01 22:28:26
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
WA  
実行時間 -
コード長 6,446 bytes
コンパイル時間 1,054 ms
コンパイル使用メモリ 94,924 KB
実行使用メモリ 17,272 KB
最終ジャッジ日時 2025-04-01 22:28:30
合計ジャッジ時間 3,652 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge1
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 1
other WA * 10
権限があれば一括ダウンロードができます

ソースコード

diff # 

#ifdef NACHIA
#define _GLIBCXX_DEBUG
#else
#define NDEBUG
#endif
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using i64 = long long;
using u64 = unsigned long long;
#define rep(i,n) for(i64 i=0; i<i64(n); i++)
const i64 INF = 1001001001001001001;
template<typename A> void chmin(A& l, const A& r){ if(r < l) l = r; }
template<typename A> void chmax(A& l, const A& r){ if(l < r) l = r; }
using namespace std;


namespace nachia{

template<
    class S,
    class F,
    S op(S l, S r),
    F composition(F f, F x),
    S mapping(F f, S x)
>
struct LazySegtree {
private:

    struct Node { S s; F f; bool propagated; };
    int N;
    int logN;
    int xN;
    std::vector<Node> A;

    void mapf(Node& a, F f){
        a.propagated = false;
        a.f = composition(f, a.f);
        a.s = mapping(f, a.s);
    }
    void mergev(int i){
        if(i<N) A[i].s = op(A[i*2].s, A[i*2+1].s);
    }
    void spread(int i){
        if(A[i].propagated || !(i < N)) return;
        mapf(A[i*2], A[i].f);
        mapf(A[i*2+1], A[i].f);
        A[i].f = A[0].f;
        A[i].propagated = true;
    }
    
    // bool cmp(S)
    template<class E>
    int minLeft2(int r, E cmp, int a = 0, int b = 0, int i = -1){
        static S x;
        if(i == -1){ a=0; b=N; i=1; x = A[0].s; }
        if(r <= a) return a;
        if(b <= r){
            S nx = op(A[i].s, x);
            if(cmp(nx)){ x = nx; return a; }
        }
        if(b-a == 1) return b;
        spread(i);
        int q = minLeft2(r, cmp, (a+b)/2, b, i*2+1);
        if(q > (a+b)/2) return q;
        return minLeft2(r, cmp, a, (a+b)/2, i*2);
    }
    // bool cmp(S)
    template<class E>
    int maxRight2(int l, E cmp, int a = 0, int b = 0, int i = -1){
        static S x;
        if(i == -1){ a=0; b=N; i=1; x = A[0].s; }
        if(b <= l) return b;
        if(l <= a){
            S nx = op(x, A[i].s);
            if(cmp(nx)){ x = nx; return b; }
        }
        if(b - a == 1) return a;
        spread(i);
        int q = maxRight2(l, cmp, a, (a+b)/2, i*2);
        if(q < (a+b)/2) return q;
        return maxRight2(l, cmp, (a+b)/2, b, i*2+1);
    }
public:

    LazySegtree() : N(0), logN(-1), xN(0){}
    LazySegtree(int n, S e, F id){
        N=1; logN=0; xN=n;
        while(N<n){ N *= 2; logN++; }
        A.assign(N*2, { e, id, true });
    }
    LazySegtree(const std::vector<S>& a, S e, F id)
        : LazySegtree(a.size(), std::move(e), std::move(id)){
        for(std::size_t i=0; i<a.size(); i++) A[i+N].s = a[i];
        for(int i=N-1; i>=1; i--) mergev(i);
    }

    void set(int p, S x){
        p += N;
        for(int d=logN; d; d--) spread(p >> d);
        A[p].s = x;
        for(int d=1; d<=logN; d++) mergev(p >> d);
    }
    S get(int p){
        p += N;
        for(int d=logN; d; d--) spread(p >> d);
        return A[p].s;
    }
    void apply(int p, F f){ set(p, mapping(f, get(p))); }
    void apply(int l, int r, F f){
        if(!(l < r)) return;
        if(l == 0 && r == N){ mapf(A[1], f); return; }
        l += N; r += N;
        for(int d=logN; d; d--){
            if((l >> d) << d != l) spread(l >> d);
            if((r >> d) << d != r) spread(r >> d);
        }
        int lp = l, rp = r;
        while(l < r){
            if(l&1){ mapf(A[l++], f); } l /= 2;
            if(r&1){ mapf(A[--r], f); } r /= 2;
        }
        for(int d=1 ; d<=logN; d++){
            if((lp >> d) << d != lp) mergev(lp >> d);
            if((rp >> d) << d != rp) mergev(rp >> d);
        }
    }
    S prod(int l, int r){
        if(!(l < r)) return A[0].s;
        l += N; r += N;
        for(int d=logN; d; d--){
            if((l >> d) << d != l) spread(l >> d);
            if((r >> d) << d != r) spread(r >> d);
        }
        S q1 = A[0].s, q2 = A[0].s;
        while(l < r){
            if(l&1){ q1 = op(q1, A[l++].s); } l /= 2;
            if(r&1){ q2 = op(A[--r].s, q2); } r /= 2;
        }
        return op(q1, q2);
    }
    S allProd() const { return A[1].s; }

    // bool cmp(S)
    template<class E>
    int minLeft(int r, E cmp){
        return minLeft2(r, cmp);
    }

    // bool cmp(S)
    template<class E>
    int maxRight(int l, E cmp){
        int x = maxRight2(l, cmp);
        return x > xN ? xN : x;
    }
};

} // namespace nachia;
#include <functional>

namespace nachia {
    template<class T, class Cmp = std::less<T>>
    struct RangeAddRangeMin{
    private:
        static T minop(T l, T r){ return std::min(l, r, Cmp()); }
        static T addop(T f, T x){ return f + x; }
        using Base = LazySegtree<T, T, minop, addop, addop>;
        Base base;
        Cmp cmpx;
    public:
        RangeAddRangeMin() {}
        RangeAddRangeMin(int len, T INF, T ZERO)
            : base(len, INF, ZERO){}
        RangeAddRangeMin(const std::vector<T>& init, T INF, T ZERO)
            : base(init, INF, ZERO){}
        T min(int l, int r){ return base.prod(l, r); }
        T min(){ return base.allProd(); }
        void add(int l, int r, T val){ base.apply(l, r, val); }
        void add(int pos, T val){ base.apply(pos, val); }
        void set(int pos, T val){ base.set(pos, val); }
        T get(int pos){ return base.get(pos); }
        int lBoundLeft(int from, T val){ return base.minLeft(from, [this,val](const T& x){ return cmpx(val, x); }); }
        int uBoundLeft(int from, T val){ return base.minLeft(from, [this,val](const T& x){ return !cmpx(x, val); }); }
        int lBoundRight(int from, T val){ return base.maxRight(from, [this,val](const T& x){ return cmpx(val, x); }); }
        int uBoundRight(int from, T val){ return base.maxRight(from, [this,val](const T& x){ return !cmpx(x, val); }); }
        template<class E>
        int minLeft(int r, E cmp){ return base.minLeft(r, cmp); }
        template<class E>
        int maxRight(int l, E cmp){ return base.maxRight(l, cmp); }
    };
} // namespace nachia

void testcase(){
    i64 N, Q; cin >> N >> Q;
    vector<i64> A(N); rep(i,N) cin >> A[i];
    auto ds = nachia::RangeAddRangeMin<i64, greater<i64>>(A, -INF, 0);
    rep(qi,Q){
        i64 t; cin >> t;
        if(t == 1){
            i64 p, x; cin >> p >> x; p--;
            ds.add(p, x);
        }
        else if(t == 2){
            i64 l, r; cin >> l >> r; l--;
            cout << ds.min() << "\n";
        }
        else {
            exit(1);
        }
    }
}

int main(){
    ios::sync_with_stdio(false); cin.tie(nullptr);
    testcase();
    return 0;
}
0