[LuoguP5055] 可持久化文艺平衡树

时间：2019-12-28 20:47:08 阅读：78 评论：0 收藏：0 [点我收藏+]

若 $opt_i=1opti?=1，则接下来两个整数 p_i,x_ipi?,xi?，表示操作为在第 p_ipi? 个数后插入数 xx 。若 opt_i=2opti?=2，则接下来一个整数 p_ipi?，表示操作为删除第 p_ipi? 个数。若 opt_i=3opti?=3，则接下来两个整数 l_i,r_ili?,ri?，表示操作为翻转区间 [l_i,r_i][li?,ri?]。若 opt_i=4opti?=4，则接下来两个整数 l_i,r_ili?,ri?，表示操作为查询区间 [l_i,r_i][li?,ri?] 的和。$

强制在线规则：
令当前操作之前的最后一次 $p_i,x_ipi?,xi? 或 l_i,r_ili?,ri? 均按位异或上 lastanslastans 即可得到真实的 p_i,x_ipi?,xi? 或 l_i,r_ili?,ri?。$

输出格式

对于每个序号为

输入输出样例

输入 #1

输出 #1

说明/提示

强制在线：以下针对 $p_i,x_i,l_i,r_ipi?,xi?,li?,ri? 的限制均是按位异或 lastanslastans 后的限制。$

对于 $30\%30% 的数据，N\le 5000N≤5000。$

对于另外 $30\%30% 的数据，v_i=i-1vi?=i−1。$

对于 $100\%100% 的数据，1\le N\le 2\times 10^51≤N≤2×105，-10^6<x_i<10^6−106<xi?<106。$

假设基于的历史版本的序列长度为 $len\ge 1len≥1，有：若 opt_i=1opti?=1，则 0\le p_i\le len0≤pi?≤len。若 opt_i=2opti?=2，则 1\le p_i\le len1≤pi?≤len。若 opt_i=3opti?=3，则 1\le l_i\le r_i\le len1≤li?≤ri?≤len。若 opt_i=4opti?=4，则 1\le l_i\le r_i\le len1≤li?≤ri?≤len。$

假设基于的历史版本的序列长度为 $00，有：opt_i=1opti?=1，p_i=0pi?=0。$

果然期末考试前最好的解压方法就是码数据结构。。

感觉和主席树有异曲同工之妙（虽然我早就把主席树忘光了）

写的可持久化fhq treap

注意只用在split的时候新建，merge不需要再新建了

pushdown也要记得新建

注意long long

#include <bits/stdc++.h>
using namespace std;
inline long long read(){
    long long f = 1, n = 0;
    char ch = getchar();
    while(!isdigit(ch)){
        if(ch == ‘-‘) f = -1;
        ch = getchar();
    }
    while(isdigit(ch)){
        n = (n << 1) + (n << 3) + (ch ^ 48);
        ch = getchar();
    }
    return f * n;
}
template<typename T>
inline void output(T x){
    if(x < 0){
        putchar(‘-‘);
        output(-x);
    }
    else{
        if(x > 9) output(x / 10);
        putchar(x % 10 + 48);
    }
}
const int maxn = 200000 + 10;
class Tree{
public:
    Tree(){
        size = 0;
        sum = val = 0;
        ls = rs = 0;
    }
    Tree(int val): val(val){
        ls = rs = 0;
        size = 1;
        sum = val;
        pri = rand();
        tag = false;
    }
    int ls, rs, size, val, pri;
    long long sum;
    bool tag;
}tree[maxn << 7];
int root[maxn], tcnt = 0;
inline int newnode(int val){
    tree[++tcnt] = Tree(val);
    return tcnt;
}
inline int copynode(int x){
    tree[++tcnt] = tree[x];
    return tcnt;
}
inline void pushup(int x){
    tree[x].size = tree[tree[x].ls].size + tree[tree[x].rs].size + 1;
    tree[x].sum = tree[tree[x].ls].sum + tree[tree[x].rs].sum + tree[x].val;
}
inline void pushdown(int x){
    if(tree[x].tag){
        if(tree[x].ls) tree[x].ls = copynode(tree[x].ls);
        if(tree[x].rs) tree[x].rs = copynode(tree[x].rs);
        swap(tree[x].ls, tree[x].rs);
        tree[tree[x].ls].tag ^= 1;
        tree[tree[x].rs].tag ^= 1;
        tree[x].tag = false;
    }
}
void split(int x, int &a, int &b, int k){
    if(!x){
        a = b = 0;
        return;
    }
    pushdown(x);
    if(tree[tree[x].ls].size + 1 <= k){
        a = copynode(x);
        split(tree[x].rs, tree[a].rs, b, k - tree[tree[x].ls].size - 1);
        pushup(a);
    }
    else{
        b = copynode(x);
        split(tree[x].ls, a, tree[b].ls, k);
        pushup(b);
    }
}
void merge(int &x, int a, int b){
    if(!a || !b){
        x = a | b;
        return;
    }
    pushdown(a); pushdown(b);
    if(tree[a].pri < tree[b].pri){
        x = a;
        merge(tree[x].rs, tree[a].rs, b);
        pushup(x);
    }
    else{
        x = b;
        merge(tree[x].ls, a, tree[b].ls);
        pushup(x);
    }
}
int main(){
    srand(19260817);
    int n = read();
    root[0] = 0;
    int v, opt, a, b, c;
    long long p, x, l, r, lastans = 0;
    for(int i = 1; i <= n; i++){
        v = read(); opt = read();
        switch(opt){
            case 1:
                p = read() ^ lastans; x = read() ^ lastans;
                split(root[v], a, b, p);
                merge(a, a, newnode(x));
                merge(root[i], a, b);
                break;
            case 2:
                p = read() ^ lastans;
                split(root[v], a, b, p - 1);
                split(b, b, c, 1);
                merge(root[i], a, c);
                break;
            case 3:
                l = read() ^ lastans; r = read() ^ lastans;
                split(root[v], a, b, l - 1);
                split(b, b, c, r - l + 1);
                tree[b].tag = 1;
                merge(b, b, c);
                merge(root[i], a, b);
                break;
            case 4:
                l = read() ^ lastans; r = read() ^ lastans;
                split(root[v], a, b, l - 1);
                split(b, b, c, r - l + 1);
                output(lastans = tree[b].sum); putchar(‘\n‘);
                merge(b, b, c);
                merge(root[i], a, b);
                break;
        }
    }
    return 0;
}

[LuoguP5055] 可持久化文艺平衡树

标签：break 针对 last min hang 整数个数 for btn

原文地址：https://www.cnblogs.com/ruoruoruo/p/12112811.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行