hdu 6464 （splay）（离线+离散化+权值线段树）

题目

题意

操作 $1$ 每次可以加入 $x$ 个 $y$，操作 $2$ 查询第 $x$ 大的数到第 $y$ 大的数的区间和

思路

splay

动态加点，查询第 $x$ 大和第 $y$ 大的元素后，通过旋转操作放在一个子树当中，很快的求出区间和，不需要离散化，操作略复杂

离线+离散化+权值线段树

通过离线可以把 $1e9$ 的数据离散化到 $1e5$ 的区间中，得到了这种映射关系之后，可以直接模拟每次单点修改和查询区间和，由于是一个权值区间，我改为了查询前 $x-1$ 个数的前缀和，以及前 $y$ 个数的前缀和，做减法即可

代码

//splay
int ch[maxn][2], pre[maxn], key[maxn];
ll sz[maxn], cnt[maxn], sum[maxn];
int root, tot;
ll lst;

void init(){
    root = tot = 0;
    ch[0][0] = ch[0][1] = pre[0] = key[0] = sz[0] = 0;
}

void push_up(int x) {
    if(!x) return ;
    sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + cnt[x];
    sum[x] = ((sum[ch[x][0]] + sum[ch[x][1]]) % mod + (cnt[x]  % mod )* key[x]) % mod;
}

inline ll judge(int x){
    return ch[pre[x]][1] == x;
}

inline void setson(int x, int fa, int k) {
    if(x) pre[x] = fa;
    if(fa) {
        ch[fa][k] = x;
        push_up(fa);
    }
    else root = x;
}

inline void rotate(int x) {
    int f = pre[x], ff = pre[pre[x]];
    int sx = judge(x), sf = judge(f);
    int p = ch[x][!sx];
    setson(p, f, sx);
    setson(x, ff, sf);
    setson(f, x, !sx);
    push_up(f);
    push_up(x);
}

inline void splay(int x, int goal) { //0-root
    while(pre[x] != goal){
        if(pre[pre[x]] == goal)
            rotate(x);
        else {
            int f = pre[x];
            if(judge(x) == judge(f)) rotate(f); 
            else rotate(x);
            rotate(x);
        }
    }
    if(!goal) root = x;
}

void ins(int &x, int val, int num, int fa){
    if(!x) {
        x = ++tot;
        key[x] = val; pre[x] = fa;
        ch[x][0] = ch[x][1] = 0;
        sz[x] = cnt[x] = num;
        sum[x] = (cnt[x] * key[x]) % mod;
    }
    else {
        if(val == key[x]) {
            cnt[x] += num;
            sum[x] = (cnt[x] * key[x]) % mod;
        }
        else val < key[x] ? ins(ch[x][0], val, num, x) : ins(ch[x][1], val, num, x); 
        push_up(x);
    }
}

void insert(int val, int num){
    ins(root, val, num, 0);
    splay(tot, 0);
}

int Kth(int u, ll k){
    if(!u) return 0;
    if(k <= sz[ch[u][0]]) return Kth(ch[u][0], k);
    if(k > sz[ch[u][0]] + cnt[u]) return Kth(ch[u][1], k-sz[ch[u][0]]-cnt[u]);
    lst = k - sz[ch[u][0]];
    return u;
}

int main()
{
    init();
    int q; sd(q);
    while(q--){
        ll op, x, y, ans = 0;
        slddd(op, x, y);
        if(op == 1){
            insert(y, x);
        } 
        else if(op == 2){
            int l = Kth(root, x);
            ans = (ans + (cnt[l] - lst + 1) * key[l]) % mod;
            int r = Kth(root, y);
            ans = (ans + lst * key[r]) % mod;
            
            if(key[l] == key[r]){
                ans = ((y - x + 1) % mod * key[l] ) % mod;
            }
            else {
                splay(l, 0);
                splay(r, l);
                ans = (ans + sum[ch[r][0]]) % mod;
            }
            pld(ans);
        }
    }
    return 0;
}

//线段树
vector<ll > v;
int getid(ll x) {return lower_bound(all(v), x) - v.begin() + 1;}

struct Node{
    int l, r;
    ll sum, cnt;
}tree[maxn<<2]; 
ll x[maxn], y[maxn], op[maxn];

void build(int i, int l, int r){
    tree[i].l = l;
    tree[i].r = r;
    tree[i].cnt = tree[i].sum = 0;
    if(l == r) return ;

    int mid = (l+r)>>1;
    build(i<<1, l, mid);
    build(i<<1|1, mid+1, r);
    return ;
}

void addx(int i, int x, ll k){
    tree[i].sum = (tree[i].sum + k*v[x-1]) % mod;
    tree[i].cnt += k;
    if(tree[i].l == tree[i].r) return ;

    int mid = (tree[i].l+tree[i].r)>>1;
    if(x <= mid) addx(i<<1, x, k);
    else addx(i<<1|1, x, k);
}

ll query(int i, ll k){
    if(tree[i].l == tree[i].r) return (v[tree[i].l - 1] * k) % mod;
    if(tree[i].cnt == k) return tree[i].sum;

    ll tmp = tree[i<<1].cnt;
    if(tmp >= k)  return query(i<<1, k);
    else return (tree[i<<1].sum + query(i<<1|1, k-tmp)) % mod;
}

int main()
{
    int q; sd(q);
    rep(i, 0, q) {
        slddd(op[i], x[i], y[i]);
        if(op[i] == 1) v.pb(y[i]);
    }

    sort(all(v));
    v.erase(unique(all(v)), v.end());
    int n = v.size();
    build(1, 1, n);

    rep(i, 0, q){
        if(op[i] == 1) addx(1, getid(y[i]), x[i]);
        else pld((query(1, y[i]) - query(1, x[i] - 1) + mod) % mod);
    }

    return 0;    
}