Submission #4065627

---

Source Code Expand

#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;--i)
#define srep(i,s,t) for(int i=(int)(s);i<(int)(t);++i)
#define each(a,b) for(auto (a): (b))
#define all(v) (v).begin(),(v).end()
#define len(v) (int)(v).size()
#define zip(v) sort(all(v)),v.erase(unique(all(v)),v.end())
#define cmx(x,y) x=max(x,y)
#define cmn(x,y) x=min(x,y)
#define fi first
#define se second
#define pb push_back
#define show(x) cout<<#x<<" = "<<(x)<<endl
#define spair(p) cout<<#p<<": "<<p.fi<<" "<<p.se<<endl
#define svec(v) cout<<#v<<":";rep(kbrni,v.size())cout<<" "<<v[kbrni];cout<<endl
#define sset(s) cout<<#s<<":";each(kbrni,s)cout<<" "<<kbrni;cout<<endl
#define smap(m) cout<<#m<<":";each(kbrni,m)cout<<" {"<<kbrni.first<<":"<<kbrni.second<<"}";cout<<endl

using namespace std;

typedef pair<int,int> P;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<double> vd;
typedef vector<P> vp;
typedef vector<string> vs;

const int MAX_N = 100005;

//永続化遅延処理型平衡二分探索木

const int max_size = 31740000;

#define getchar getchar_unlocked
#define putchar putchar_unlocked

inline int in() {
    int n, c, flag = 1;
    while ((c = getchar()) < '0') if (c == EOF) return -1; else flag = -1;
    n = c - '0';
    while ((c = getchar()) >= '0') n = n * 10 + c - '0';
    return n * flag;
}

inline void out(ll n) {
    short res[20], i = 0;
    if(n < 0) putchar('-'), n = -n;
    do { res[i++] = n % 10, n /= 10; } while (n);
    while (i) putchar(res[--i] + '0');
    putchar('\n');
}

#define T ll

class RBST {
public:
    struct node{
        T val, lazy, al;
        int st_size;   // 部分木のサイズ
        node* left; node* right;
        node(){};
        node(T v) : val(v), lazy(0LL), al(v), st_size(1LL), left(nullptr), right(nullptr){}
        ~node() { delete left; delete right; }
    };
    using pnn = pair<node*,node*>;
    node* memo; //永続配列
    int pool_size;
    node* root;
    RBST(){
        memo = new node[max_size];
    }
    //永続化
    node* fix(node* t){
        if(!t)  return t;
        // if(pool_size >= max_size) assert(false);
        memo[pool_size] = *t;
        return &memo[pool_size++];
    }
    int size(node* t) { return t ? t->st_size : 0; }
    T que(node* t) { return t ? t->al + t->lazy*size(t) : 0LL; }
    //遅延伝播
    node* push(node* t){
        if(!t) return t;
        t = fix(t);
        if(t->lazy){
            if(t->left){
                t->left = fix(t->left);
                t->left->lazy += t->lazy;
            }
            if(t->right){
                t->right = fix(t->right);
                t->right->lazy += t->lazy;
            }
            t->val += t->lazy;
            t->al = que(t->left) + t->val + que(t->right);
            t->lazy = 0LL;
        }
        return t;
    }
    node* update(node *t){
        node* l = t->left; node* r = t->right;
        t->st_size = size(l) + size(r) + 1;
        t->al = que(l) + que(r) + t->val;
        return t;
    }
    unsigned rnd() {
        static unsigned y = 246343424;
        y = y ^ (y << 13); y = y ^ (y >> 17);
        return y = y ^ (y << 5);
    }
    node* merge(node* l, node* r){
        if (!l || !r) return (!l) ? r : l;
        if(rnd() % (size(l) + size(r)) < (unsigned)size(l)){
            l = push(l);
            l->right = merge(l->right, r);
            return update(l);
        }else{
            r = push(r);
            r->left = merge(l, r->left);
            return update(r);
        }
    }
    pnn split(node* t, int k){   //木のサイズが(k,n-k)となるように分割する
        if(!t) return pnn(nullptr, nullptr);
        t = push(t);
        if(k <= size(t->left)){
            pnn s = split(t->left, k);
            t->left = s.second;
            return pnn(s.first,update(t));
        }else{
            pnn s = split(t->right, k-size(t->left)-1);
            t->right = s.first;
            return pnn(update(t), s.second);
        }
    }
    T* x;    //再構築の際にも用いる
    int i, x_size;
    void build(int n){
    	pool_size = 0;
    	node *res = nullptr;
    	for (i = 0; i < n; i++) {
    		memo[pool_size] = node(in());
    		res = merge(res, &memo[pool_size++]);
    	}
    	root = res;
    }
    void up(node *t) {
    	if (!t) return;
    	t = push(t);
    	up(t->left);
    	x[x_size++] = t->val;
    	up(t->right);
    }
    void rebuild(node* t) {
    	x_size = 0;
    	up(t);
        pool_size = 0;
    	node *res = nullptr;
    	for (i = 0; i < x_size; i++) {
    		memo[pool_size] = node(x[i]);
    		res = merge(res, &memo[pool_size++]);
    	}
    	root = res;
    }
    void add(int l, int r, T val){
        auto sr = split(root, r);
        auto sl = split(sr.first, l);
        node* lr = sl.second;
        lr->lazy += val;
        root = merge(merge(sl.first,sl.second),sr.second);
    }
    //[r,s)を[p,q)にコピー
    void trans(int p, int q, int r, int s){
        auto sq = split(root,q);
        auto sp = split(sq.first,p);
        auto ss = split(root,s);
        auto sr = split(ss.first,r);
        root = merge(merge(sp.first,sr.second),sq.second);
    }
    void query(int l,int r){
        auto sr = split(root,r);
        auto sl = split(sr.first,l);
        out(que(sl.second));
    }
};

int main()
{
    int n = in(), q = in();
    // scanf("%d%d",&n,&q);
    RBST rb;
    rb.x = new ll[n];
    rb.build(n);
    rep(i,q){
        short a = in();
        // scanf("%d",&a);
        if(a == 1){
            int b = in(), c = in(), d = in();
            // scanf("%d%d%d",&b,&c,&d);
            rb.add(b-1,c,d);
        }else if(a == 2){
            int b = in(), c = in(), d = in(), e = in();
            // scanf("%d%d%d%d",&b,&c,&d,&e);
            rb.trans(b-1,c,d-1,e);
        }else{
            int b = in(), c = in();
            // scanf("%d%d",&b,&c);
            // printf("%lld\n",rb.query(b-1,c));
            rb.query(b-1,c);
        }
        if(rb.pool_size >= max_size / 2){
            rb.rebuild(rb.root);
        }
    }
    return 0;
}

Submission Info

Judge Result