P5283 [十二省联考2019]异或粽子可持久化01Trie+线段树

$ \color{#0066ff}{ 题目描述 }$

小粽是一个喜欢吃粽子的好孩子。今天她在家里自己做起了粽子。

小粽面前有 $n$ 种互不相同的粽子馅儿，小粽将它们摆放为了一排，并从左至右编号为 $1$ 到 $n$。第 $i$ 种馅儿具有一个非负整数的属性值 $a_i$。每种馅儿的数量都足够多，即小粽不会因为缺少原料而做不出想要的粽子。小粽准备用这些馅儿来做出 $k$ 个粽子。

小粽的做法是：选两个整数数 $l$, $r$，满足 $1 \leqslant l \leqslant r \leqslant n$，将编号在 $[l, r] 范围$内的所有馅儿混合做成一个粽子，所得的粽子的美味度为这些粽子的属性值的异或和。（异或就是我们常说的 xor 运算，即 C/C++ 中的 ˆ 运算符或 Pascal 中的 xor 运算符）

小粽想品尝不同口味的粽子，因此它不希望用同样的馅儿的集合做出一个以上的粽子。

小粽希望她做出的所有粽子的美味度之和最大。请你帮她求出这个值吧！

$\color{#0066ff}{输入格式}$

第一行两个正整数 $n$,$k$，表示馅儿的数量，以及小粽打算做出的粽子的数量。

接下来一行为 $n$ 个非负整数，第 $i$ 个数为 $a_i$，表示第 $i$ 个粽子的属性值。对于所有的输入数据都满足：$1 \leqslant n \leqslant 5 \times 10^5$, $1 \leqslant k \leqslant \min\left\{\frac{n(n-1)}{2},2 \times 10^{5}\right\}$$0 \leqslant a_i \leqslant 4 294 967 295$

$\color{#0066ff}{输出格式}$

输出一行一个整数，表示小粽可以做出的粽子的美味度之和的最大值。

$\color{#0066ff}{输入样例}$

3 2

1 2 3

$\color{#0066ff}{输出样例}$

$\color{#0066ff}{数据范围与提示}$

测试点	$n$	$k$
$1$, $2$, $3$, $4$, $5$, $6$, $7$, $8$	$\leqslant 10^3$	$\leqslant 10^3$
$9$, $10$, $11$, $12$	$\leqslant 5 \times 10^5$	$\leqslant 10^3$
$13$, $14$, $15$, $16$	$\leqslant 10^3$	$\leqslant 2 \times 10^5$
$17$, $18$, $19$,$20$	$\leqslant 5 \times 10^5$	$\leqslant 2 \times 10^5$

$\color{#0066ff}{题解}$

显然可以转换一下，求一下前缀和，问题就变成了前k大两两异或和

建立一个可持久化01Trie，发现可以类似权值线段树求第k大，然后就水了。。。

用线段树维护每一个$s_i$的最优的$s_j(j<i)$使得$s_i \ \ xor \ \ s_j$最大

每次加上线段树最大值，然后找到最大值取到的位置，在01Trie上找次大的在线段树上更新就行了

蒟蒻考场上只写了60的暴力。。。。

然而本题貌似卡指针，反正数组过了23333

// luogu-judger-enable-o2

#include<bits/stdc++.h>

#define LL long long

LL in() {

    char ch; LL x = 0, f = 1;

    while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);

    for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));

    return x * f;

}

template<class T> bool chkmax(T &a, const T &b) { return a < b? a = b, 1 : 0; }

template<class T> bool chkmin(T &a, const T &b) { return b < a? a = b, 1 : 0; }

const int maxn = 5e5 + 100;

struct SGT {

    protected:

        struct node {

            node *ch[2];

            int l, r, id;

            LL val;

            node(int l = 0, int r = 0, LL val = 0): l(l), r(r), val(val) { ch[0] = ch[1] = NULL; }

            void upd() { val = std::max(ch[0]->val, ch[1]->val); }

            int mid() { return (l + r) >> 1; }

        }*root, *tail, pool[maxn << 2];

        void build(node *&o, int l, int r) {

            o = new(tail++) node(l, r);

            if(l == r) return;

            build(o->ch[0], l, o->mid());

            build(o->ch[1], o->mid() + 1, r);

        }

        void lazy(node *o, int pos, LL val) {

            if(o->l == o->r) return (void)(o->val = val);

            if(pos <= o->mid()) lazy(o->ch[0], pos, val);

            else lazy(o->ch[1], pos, val);

            o->upd();

        }

    public:

        SGT() { tail = pool; }

        void lazy(int pos, LL val) { lazy(root, pos, val); }

        void init(int n) { build(root, 1, n); }

        LL getans() { return root->val; }

        int getpos() {

            node *o = root;

            while(o->l != o->r) o = o->ch[o->ch[0]->val <= o->ch[1]->val];

            return o->l;

        }

}T;

LL a[maxn], k, n, cont[maxn];

struct Tree {

    Tree *ch[2];

    int num;

    Tree(int num = 0): num(num) { ch[0] = ch[1] = NULL; }

}*root[maxn], pool[maxn << 6], *tail;

void add(Tree *&o, Tree *lst, int dep, LL val) {

    o = new(tail++) Tree(), *o = *lst, o->num++;

    if(!(~dep)) return;

    if(val & (1LL << dep)) add(o->ch[1], lst->ch[1], dep - 1, val);

    else add(o->ch[0], lst->ch[0], dep - 1, val);

}

LL getkth(Tree *o, int dep, LL val, int nowk) {

    if(dep == -1) return 0;

    int now = val & (1LL << dep)? 1 : 0;

    if(nowk <= o->ch[now ^ 1]->num) return getkth(o->ch[now ^ 1], dep - 1, val, nowk) | (1LL << dep);

    else return getkth(o->ch[now], dep - 1, val, nowk - o->ch[now ^ 1]->num);

}

void init() {

    tail = pool;

    root[0] = new(tail++) Tree();

    root[0]->ch[0] = root[0]->ch[1] = root[0];

}

signed main() {

    n = in(), k = in();

    T.init(n);

    for(int i = 1; i <= n; i++) a[i] = a[i - 1] ^ in();

    init();

    for(int i = 1; i <= n; i++) add(root[i], root[i - 1], 31, a[i - 1]);

    for(int i = 1; i <= n; i++) T.lazy(i, getkth(root[i], 31, a[i], ++cont[i]));

    LL ans = 0;

    while(k --> 0) {

        LL now = T.getans();

        ans += now;

        int nowpos = T.getpos();

        T.lazy(nowpos, getkth(root[nowpos], 31, a[nowpos], ++cont[nowpos]));

    }

    printf("%lld\n", ans);

    return 0;

}