[省选联考 2024] 魔法手杖

退役三年选手回来做了下～

这题直观感觉很吓人，其实看到异或就可以往 Trie 树上思考了。

这题有两个未知量 \(S\) 和 \(x\)，其中 \(S\subseteq [n]\)，\(x\in[0,2^k)\cap\Z\)，状态过于复杂，肯定不能枚举，从答案的角度考虑。首先直观感受是有点像二分，其实我们可以从高位往低位确定答案 \(ans\)。

分析一下得出结论：\(ans\) 的二进制长度最长为 \(k+1\) 位（注意这里是个特殊情况），当且仅当 \(\sum b_i\le m\)，这个时候根据贪心，取 \(x=2^k-1\) 即可，此时 \(ans=\min\{b_i\}+x\)。

否则，\(ans\) 最长为 \(k\) 位，我们可以从高往低确定 \(ans\)。假设当前正在讨论第 \(d\) 位，根据贪心，我们需要判断第 \(d\) 位是否可以为 1。假如我们把所有的 \(a_i\) 插入一棵 Trie 树，对于 \(val(S,x)=\min(\min \limits_{i \in S}(a_i+x),\min \limits_{i \in U \backslash S}(a_i \oplus x))\)，我们称由 \(+\) 部分和 \(\oplus\) 部分组成。如果希望结果越大，也就是两个部分必须超过 \(ans\) 才可以。

这个时候，我们需要先确定 \(x\) 的第 \(d\) 位的取值，我们分 \(x=0\) 和 \(x=1\) 两种情况。在此基础上，\(S\) 的决策会影响 \(ans\) 的第 \(d\) 位。我们需要仔细分析一下，看一看能不能变成一个判定性问题。

假设此时在 Trie 树上的节点 \(u\)，如果左右孩子都存在，当 \(x\) 取 0 时，左子树的所有值在 \(\oplus\) 部分会贡献出 \(ans=0\)，右子树的所有值在 \(\oplus\) 部分会贡献出 \(ans=1\)，此时我们可以考虑将左子树移到 \(+\) 部分，尝试一下 \(ans\) 变成 1。考虑下影响：\(S\) 中的最小值更新了，这里用 \(y\) 表示，那么需要满足两个条件：1、左子树的 \(b\) 的和不超过剩余值（初始值位 \(m\)）；2、\(+\) 部分必须超过当前的 \(ans\)（\(ans\) 未确定部分全部置成 0，\(x\) 未确定部分全部置成 1，极端情况的考虑）。只有这两个条件满足了，才能确定 \(ans\) 的第 \(d\) 位可以为 1，那么递归右子树，继续确定 \(d-1\) 位。\(x\) 取 1 时刚好对称。

所以得到了一个 贪心+dfs 的思路。先判断 \(ans\) 是否可以为 1，如果可以需要递归两种情况（合法时才递归），否则 \(ans\) 为 0，此时 \(x\) 取 0 时右子树可以忽略，递归左子树，反之亦然。也是两种情况。注意一下边界（\(d=-1\) 或者 \(u\) 是空节点）。

时间复杂度 \({\rm O}(\sum nk)\)，空间复杂度 \({\rm O}(nk)\)。代码想清楚的话很好写。

由于官方数据还没出来，大样例和民间数据都过了，先占个位置。代码有问题回头再修改。

#include<bits/stdc++.h>
using namespace std;

void read(__int128 &x){
    // read a __int128 variable
    char c; bool f = 0;
    while (((c = getchar()) < '0' || c > '9') && c != '-');
    if (c == '-') { f = 1; c = getchar(); }
    x = c - '0';
    while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
    if (f) x = -x;
}
void write(__int128 x){
    // print a __int128 variable
    if (x < 0) { putchar('-'); x = -x; }
    if (x > 9) write(x / 10);
    putchar(x % 10 + '0');
}

typedef long long ll;
const int N = 1e5 + 5, K = 120 + 5;
int T, c, n, m, k, ch[N * K][2], cnt;
int b[N]; ll sumb[N * K];
__int128 a[N], mina[N * K], ans;
int nnode() {
    cnt++;
    ch[cnt][0] = ch[cnt][1] = 0;
    mina[cnt] = (__int128)1 << k;
    sumb[cnt] = 0;
    return cnt;
}
void solve(int o, int d, int t, __int128 x, __int128 y, __int128 z) {
    if (d == -1) {
        ans = max(ans, z);
        return;
    }
    __int128 bit = (__int128)1 << d, mask = bit - 1;
    if (!o) {
        ans = max(ans, y + (x | mask | bit));
        return;
    }
    int lc = ch[o][0], rc = ch[o][1];
    bool flag = false;
    if (sumb[lc] <= t && (x | mask) + min(y, mina[lc]) >= (z | bit))
        solve(rc, d - 1, t - sumb[lc], x, min(y, mina[lc]), z | bit), flag = true;
    if (sumb[rc] <= t && (x | mask | bit) + min(y, mina[rc]) >= (z | bit))
        solve(lc, d - 1, t - sumb[rc], x | bit, min(y, mina[rc]), z | bit), flag = true;
    if (flag) return;
    solve(lc, d - 1, t, x, y, z);
    solve(rc, d - 1, t, x | bit, y, z);
}
int main() {
    freopen("xor.in", "r", stdin);
    freopen("xor.out", "w", stdout);
    scanf("%d%d", &c, &T);
    while (T--) {
        scanf("%d%d%d", &n, &m, &k);
        for (int i = 1; i <= n; i++) read(a[i]);
        for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
        cnt = 0; nnode();
        __int128 MAX = (__int128)1 << k;
        mina[0] = MAX;
        for (int i = 1; i <= n; i++) {
            int u = 1;
            sumb[u] += b[i];
            mina[u] = min(mina[u], a[i]);
            for (int j = k - 1; ~j; j--) {
                int x = a[i] >> j & 1;
                if (!ch[u][x]) ch[u][x] = nnode();
                u = ch[u][x];
                mina[u] = min(mina[u], a[i]);
                sumb[u] += b[i];
            }
        }
        ans = 0;
        if (sumb[1] <= m)
            ans = mina[1] + MAX - 1;
        else
            solve(1, k - 1, m, 0, MAX, 0);
        write(ans); putchar('\n');
    }
    return 0;
}