BZOJ3217 ALOEXT

3217: ALOEXT

Time Limit: 25 Sec  Memory Limit: 512 MB

Description

taorunz平时最喜欢的东西就是可移动存储器了……只要看到别人的可移动存储器，他总是用尽一切办法把它里面的东西弄到手。

突然有一天，taorunz来到了一个密室，里面放着一排可移动存储器，存储器里有非常珍贵的OI资料……不过比较特殊的是，每个存储器上都写着一个非负整数。taorunz很高兴，要把所有的存储器都拿走（taorunz的智商高达500，他一旦弄走了这里的所有存储器，在不久到来的AHOI和NOI中……你懂的）。不过这时有一个声音传来：“你只能拿走这里的一个存储器，而且还不能直接拿，你需要指定一段区间[l, r]，满足l<r，然后在第l个和第r个存储器之间选一个拿走，你能获得的知识增加量等于区间[l, r]中所有存储器上写的整数的次大值与你拿走的这个存储器上写的整数作按位异或运算的结果。”

问题是，这里的可移动存储器数量太多，而且，它们还在不断地发生变化，有时候天上会掉下来一个新的存储器，并插入到这一排存储器中，有时候某个存储器会不明原因消失，有时候某个存储器上写的整数变化了。taorunz虽然智商很高，但也无法应对如此快的变化，他指定了许多段区间，让你帮他找出如果在这个区间中拿走存储器，他能获得的最多的知识是多少。

Input

第一行两个整数N、M，表示一开始的存储器数和后面发生的事件数。

第二行N个非负整数，表示一开始从左到右每个存储器上写的数字。注意，存储器从0开始编号，也就是最左边的存储器是第0个。

接下来M行，每行描述一个事件，有4种可能的事件。

（1）I x y：表示天上掉下来一个写着数字y的存储器，并插入到原来的第x个存储器之前，如果x等于原来存储器的个数，则插入到末尾；

（2）[D] x：表示第x个存储器消失；

（3）C x y：表示第x个存储器上写的数字变为y；

（4）F l r：表示taorunz指定区间[l, r]，让你告诉他最多能获得多少知识。

注意，本题强制在线，也就是事件中出现的所有数字都进行了加密，数字s表示的真实值是

对于I、[D]、C事件中的x及F事件中的l、r：(s+last_ans) mod n0；

对于I、C事件中的y：(s+last_ans) mod 1048576。

其中n0为目前存储器个数，last_ans为上一个F事件的结果，如果前面尚未发生F事件，则last_ans=0。

Output

对于每个F事件，输出结果。

Sample Input

5 10
2 6 3 8 7
F 1 4
I 2 1048565
I 0 1048566
D 3
F 3 0
I 3 1048569
D 5
C 1 1048570
F 1 2
F 2 1

Sample Output

15
7
4
7

HINT

1<=N, M<=100000。所有F事件满足l<r。

本题共有5组数据，除1组为随机数据外，其它数据均为人工构造。

Source

By mato_no1

---

又是一道卡了3天的神犇树套树。

首先，样例有问题，[D]在测试数据里是D。

好吧，替罪羊套trie，听着就sb，写起来也sb的题，替罪羊爱咋写咋写

删除是本题唯一的难点，不能直接删，删了的话替罪羊就会开始疯狂重构，直接GG，打个标记，咱当这点不存在。

所以记录一个sz，一个max_sz，sz就是还被删除的点的个数，max_sz是总和，序列找点用sz，平时的sz + 1等要改成sz + (!t[rt].del)，替罪羊判断是否重构用max_sz，重构也不要删掉打了标记的点。网上有大佬用类似线段树的方式建替罪羊，把序列全部建在叶子节点，这样就避免的删除带来的困扰，但他的代码在我对拍的时候GG了，大家观摩思想就好，别抄代码。。。

然后就没有然后了，题目有点卡，alpha推荐0.75。

---

ACcode：

#include<bits/stdc++.h>
using namespace std;
template <class _T> inline void read(_T &_x) {
    int _t; bool flag = false;
    while ((_t = getchar()) != '-' && (_t < '0' || _t > '9')) ;
    if (_t == '-') _t = getchar(), flag = true; _x = _t - '0';
    while ((_t = getchar()) >= '0' && _t <= '9') _x = _x * 10 + _t - '0';
    if (flag) _x = -_x;
}
typedef long long LL;
const int DEP = 20;
const int maxv = 200010;
const int MOD = 1048576;
namespace T {
    const int maxt = maxv * DEP * 8;
    struct Tnode {
        int v, ch[2];
    }t[maxt];
    int st[maxt], top, tot;
    inline int newnode() {
        if (!top) st[top++] = ++tot;
        int cur = st[--top];
        t[cur].v = t[cur].ch[0] = t[cur].ch[1] = 0;
        return cur;
    }
    void reclaim(int rt) {
        if (!rt) return ;
        reclaim(t[rt].ch[0]), reclaim(t[rt].ch[1]);
        st[top++] = rt;
    }
    void insert(int &rt, int val, int dep) {
        if (!rt) rt = newnode(); ++t[rt].v;
        if (dep < 0) return ;
        insert(t[rt].ch[(val>>dep)&1], val, dep - 1);
    }
    void remove(int &rt, int val, int dep) {
        --t[rt].v;
        if (!t[rt].v) {
            reclaim(rt), rt = 0;
            return ;
        }
        if (dep < 0) return ;
        remove(t[rt].ch[(val>>dep)&1], val, dep - 1);
    }
    int merge(int a, int b) {
        if (!a && !b) return 0;
        int rt = newnode();
        t[rt].v = t[a].v + t[b].v;
        t[rt].ch[0] = merge(t[a].ch[0], t[b].ch[0]);
        t[rt].ch[1] = merge(t[a].ch[1], t[b].ch[1]);
        return rt;
    }
}
namespace S { //scapegoat
    const double alpha = 0.75;
    struct Snode {
        int v, l, r;
        int sz, max_sz, root;
        bool del;
    }t[maxv];
    int st[maxv], top, tot;
    int Root;
    void print(int rt) {
        if (!rt) return ;
        //putchar('[');
        print(t[rt].l);
        if (!t[rt].del) printf("%d ", t[rt].v);
        print(t[rt].r);
        //putchar(']');
    }
    inline void Print() {
        cout << "Seq: ";
        print(Root);
        cout << endl;
    }
    inline bool isbad(int rt) {
        return t[rt].max_sz * alpha < max(t[t[rt].l].max_sz, t[t[rt].r].max_sz);
    }
    inline int newnode(int val) {
        if (!top) st[top++] = ++tot;
        int cur = st[--top];
        t[cur].v = val;
        t[cur].root = t[cur].l = t[cur].r = t[cur].del = 0;
        t[cur].sz = t[cur].max_sz = 0;
        return cur;
    }
    void reclaim(int rt) {
        if (!rt) return ;
        reclaim(t[rt].l), reclaim(t[rt].r);
        T::reclaim(t[rt].root);
        st[top++] = rt;
    }
    int v0[maxv], cnt;
    void dfs_node(int rt) {
        if (!rt) return ;
        dfs_node(t[rt].l);
        v0[++cnt] = t[rt].del ? -1 : t[rt].v;
        dfs_node(t[rt].r);
    }
    void build(int &rt, int l, int r) {
        int mid = (l + r) >> 1;
        rt = newnode(v0[mid]);
        if (t[rt].v == -1) t[rt].del = true;
        if (l < mid) build(t[rt].l, l, mid - 1);
        if (mid < r) build(t[rt].r, mid + 1, r);
        t[rt].sz = t[t[rt].l].sz + t[t[rt].r].sz + (!t[rt].del);
        t[rt].max_sz = t[t[rt].l].max_sz + t[t[rt].r].max_sz + 1;    
        t[rt].root = T::merge(t[t[rt].l].root, t[t[rt].r].root);
        if (!t[rt].del) T::insert(t[rt].root, t[rt].v, DEP - 1);
    }
    void rebuild(int &rt) {
        cnt = 0, dfs_node(rt);
        reclaim(rt);
        build(rt, 1, cnt);
    }
    int badroot;
    void insert(int &rt, int pos, int val) {
        if (!rt) {
            rt = newnode(val);
            ++t[rt].sz, ++t[rt].max_sz;
            T::insert(t[rt].root, val, DEP - 1);
            return ;
        }
        ++t[rt].sz, ++t[rt].max_sz;
        T::insert(t[rt].root, val, DEP - 1);
        if (pos <= t[t[rt].l].sz + (!t[rt].del)) insert(t[rt].l, pos, val);
        else insert(t[rt].r, pos - t[t[rt].l].sz - (!t[rt].del), val);
        if (isbad(rt)) badroot = rt;
    }
    int change(int rt, int pos, int val) {
        int ret = 0;
        if (!t[rt].del && pos == t[t[rt].l].sz + 1) {
            ret = t[rt].v, t[rt].v = val;
            T::insert(t[rt].root, val, DEP - 1),
            T::remove(t[rt].root, ret, DEP - 1);
            return ret;
        }
        if (pos <= t[t[rt].l].sz) ret = change(t[rt].l, pos, val);
        else ret = change(t[rt].r, pos - t[t[rt].l].sz - (!t[rt].del), val);
        T::insert(t[rt].root, val, DEP - 1),
        T::remove(t[rt].root, ret, DEP - 1);
        return ret;
    }
    int remove(int rt, int pos) {
        --t[rt].sz;
        if (!t[rt].del && pos == t[t[rt].l].sz + 1) {
            t[rt].del = true;
            T::remove(t[rt].root, t[rt].v, DEP - 1);
            return t[rt].v;
        }
        int ret = 0;
        if (pos <= t[t[rt].l].sz) ret = remove(t[rt].l, pos);
        else ret = remove(t[rt].r, pos - t[t[rt].l].sz - (!t[rt].del));
        T::remove(t[rt].root, ret, DEP - 1);
        return ret;
    }
    inline void Init(int n) {
        for (int i = 1; i <= n; ++i) read(v0[i]);
        build(Root, 1, n);
    }
    inline void Insert(int pos, int val) {
        //printf("Insert %d before position %d\n", val, pos);
        badroot = 0;
        insert(Root, pos + 1, val);
        if (badroot) rebuild(badroot);
    }
    inline void Change(int pos, int val) {
        //printf("Change position %d to %d\n", pos, val);
        change(Root, pos + 1, val);
    }
    inline void Delete(int pos) {
        //printf("Delete position %d\n", pos);
        remove(Root, pos + 1);
    }
    struct Qnode {
        int v, rt;
        Qnode(int a = 0, int b = 0):v(a), rt(b) {}
    }p[maxv], ori[maxv];
    int pcnt;
    void dfs_part(int rt, int pos) {
        if (!pos) return ;
        if (pos == t[t[rt].l].sz) {
            p[++pcnt] = Qnode(1, t[t[rt].l].root);
        } else if (pos < t[t[rt].l].sz) {
            dfs_part(t[rt].l, pos);
        } else {
            p[++pcnt] = Qnode(1, t[rt].root);
            p[++pcnt] = Qnode(-1, t[t[rt].r].root);
            dfs_part(t[rt].r, pos - t[t[rt].l].sz - (!t[rt].del));
        }
    }
    inline int Query(int l, int r) {
        ++l, ++r;
        //printf("Query in range [%d, %d]\n", l, r);
        pcnt = 0;
        dfs_part(Root, l - 1);
        for (int i = 1; i <= pcnt; ++i) p[i].v = -p[i].v;
        dfs_part(Root, r);
        memcpy(ori + 1, p + 1, pcnt * sizeof(Qnode));
        int ret = 0, k = 2;
        LL totl, totr;
        int L = 0, R = (1<<DEP) - 1;
        for (int dep = DEP - 1; dep >= 0; --dep) {
            totl = totr = 0;
            for (int i = 1; i <= pcnt; ++i) {
                //totl += p[i].v * T::t[T::t[p[i].rt].ch[0]].v;
                totr += p[i].v * T::t[T::t[p[i].rt].ch[1]].v;
            }
            //printf("%d - %d & %d - %d: %I64d %I64d\n", L, L + (1<<dep) - 1, L + (1 << dep), R, totl, totr);
            if (totr < k) {
                k -= (int)totr;
                R -= 1 << dep;
                for (int i = 1; i <= pcnt; ++i)
                    p[i].rt = T::t[p[i].rt].ch[0];
            } else {
                ret += 1 << dep;
                L += 1 << dep;
                for (int i = 1; i <= pcnt; ++i)
                    p[i].rt = T::t[p[i].rt].ch[1];
            }
        }
        //cout << ret << endl;
        memcpy(p + 1, ori + 1, pcnt * sizeof(Qnode));
        int ans = 0;
        for (int dep = DEP - 1; dep >= 0; --dep) {
            totl = 0, totr = 0;
            for (int i = 1; i <= pcnt; ++i) {
                totl += p[i].v * T::t[T::t[p[i].rt].ch[0]].v;
                totr += p[i].v * T::t[T::t[p[i].rt].ch[1]].v;
            }
            if (!totl || (totr && ((ret>>dep)&1) == 0)) {
                ans += 1 << dep;
                for (int i = 1; i <= pcnt; ++i)
                    p[i].rt = T::t[p[i].rt].ch[1];
            } else {
                for (int i = 1; i <= pcnt; ++i)
                    p[i].rt = T::t[p[i].rt].ch[0];
            }    
        }
        //cout << ans << endl;
        return ans ^ ret;
    }
}
int main() {
    //freopen("3217.in", "r", stdin);
    //freopen("3217.out", "w", stdout);
    int n, m;
    read(n), read(m);
    S::Init(n);
    char op[20];
    int lastans = 0, n0 = n;
    for (int i = 1, a, b; i <= m; ++i) {
        //S::Print();
        scanf("%s", op);
        switch (op[0]) {
            case 'I':
                read(a), read(b);
                a = (a + lastans) % n0;
                b = (b + lastans) % MOD;
                S::Insert(a, b);
                ++n0;
                break;
            case 'D':
                read(a);
                a = (a + lastans) % n0;
                S::Delete(a);
                --n0;
                break;
            case 'C':
                read(a), read(b);
                a = (a + lastans) % n0;
                b = (b + lastans) % MOD;
                S::Change(a, b);
                break;
            case 'F':
                read(a), read(b);
                a = (a + lastans) % n0;
                b = (b + lastans) % n0;
                printf("%d\n", lastans = S::Query(a, b));
                break;
        }
    }
    return 0;
}

良心数据生成器：

#include<bits/stdc++.h>
using namespace std;
int main () {
    freopen("test.in", "w", stdout);
    srand(time(NULL));
    int n = 5, m = 5;
    cout << n << ' ' << m << endl;
    for (int i = 1; i <= n; ++i) {
        cout << rand() % 100 << ' ';
    }
    cout << endl;
    int n0 = n;
    for (int i = 1, a, b; i <= m; ++i) {
        int op = rand() % 4;
        while (n0 <= 2 && op == 1) op = rand() % 4;
        switch (op) {
            case 0:
                a = rand() % n0;
                b = rand() % 100;
                printf("I %d %d\n", a, b);
                ++n0;
                break;
            case 1:
                a = rand() % n0;
                printf("D %d\n", a);
                --n0;
                break;
            case 2:
                a = rand() % n0;
                b = rand() % 100;
                printf("C %d %d\n", a, b);
                break;
            case 3:
                a = rand() % (n0 - 1);
                b = a + rand() % (n0 - a - 1) + 1;
                printf("F %d %d\n", a, b);
                break;
        }
    }
    return 0;
}