牛客 2024 暑假训练营, D- XOR of Suffix Sums 题解

题意

原题链接

有一个起始为空的数组, 每次操作从尾部删除 t 个数, 在在尾部加一个数. 求每次操作( 最多 5e5 次) 后的后缀和的异或和. 对 $2^{21}$ 取模.

思路

1. 首先注意到每次插入一个数, 那数组的累计长度不超过 5e5, 可以枚举 t 的删除操作.
2. 多个数的异或和维护, 很容易想到按 Bit 位维护. 具体这么维护:
   1. 如果维护后缀和的话, 每次在末尾插入删除一个数, 所有的 suf 都会改变, 很难维护, 不妨维护 pre[len]-pre[i-1]=suf[i], 这样每次更改都只有pre[len]改变, (注意, 这里的 len 是加一或减一(完成了插入或删除)后的 len).
   2. 有一个小 tip, 针对第 d Bit 位, suf[i] 的第 d 位为 1 等价于:
      => $suf[i]mod{2}^{d+1}>=2^d$
      => $(pre[n]-pre[i])mod{2}^{d+1}>=2^d$
      记 $x=-pre[i-1]$:
      => $(pre[n]+x)mod{2}^{d+1}>=2^d$
      由于这时全是在模$2^{d+1}$环境下的, 数的值域不大, 可以直接用树状数组维护任意范围内 x 的数量.
   3. 那么问题来了, x 的范围是多少?
      注意到, 式子中的 pre[n] 和 x 都是在模$2^{d+1}$环境下的, 不大于模数. 故二者和的范围为$0到2\ast 2^{d+1}$.
      那么满足$>=2^d$的范围就很明了了.
      $2^d<=pre[n]+x<2^{d+1}$ 或 $2^{d+1}+2^d<=pre[n]+x<2\ast 2^{d+1}$
      就可以在树状数组中维护这两个范围内 x 的个数, 就是这 Bit 位上 1 的个数, 就得到了这 Bit 位上的异或答案. 这样维护 21 颗树状数组, 就得到了答案.

#include<bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "D:\Users\TauLee\OneDrive\Mine\c++\debug.h"
#else
#define debug(...) 42;
#define endl '\n'
#endif

#define int long long
const int Maxn = 3e6 + 10;
int tr[30][Maxn], a[Maxn], pre[Maxn], Pow[30];
void upd(int *tr, int x, int k) { // 第i颗树维护模pow(2,i+1)的量
    x++; // 偏移一位
    for (; x < Maxn; x += (x & -x))tr[x] += k;
}
int ask(int *tr, int x) {
    x++;
    int ans = 0;
    for (; x; x -= (x & -x))ans += tr[x];
    return ans;
}
int mod(int x, int i) {
    return x % Pow[i] + Pow[i];
}
signed main()
{
    ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
    Pow[0] = 1;
    for (int i = 1; i <= 21; ++i) Pow[i] = Pow[i - 1] * 2;

    int q, t, v, n = 0;
    for (int i = 0; i <= 20; ++i) {
        upd(tr[i], 0, 1);
    }
    cin >> q;
    while (q--) {
        cin >> t >> v;
        while (t--) {
            for (int i = 0; i <= 20; ++i) {
                upd(tr[i], mod(-pre[n], i + 1), -1);
            }
            n--;
        }
        a[++n] = v;
        pre[n] = pre[n - 1] + v;

        int ans = 0;
        for (int i = 0; i <= 20; ++i) {
            int num = 0;
            int l = max(0ll, Pow[i] - pre[n] % Pow[i + 1]);
            int r = Pow[i + 1] - pre[n] % Pow[i + 1] - 1;
            num += ask(tr[i], r) - ask(tr[i], l - 1);
            l = Pow[i] + Pow[i + 1] - pre[n] % Pow[i + 1];
            num += n - ask(tr[i], l - 1);
            if (num % 2)ans += (1ll << i);
        }
        cout << ans << endl;

        for (int i = 0; i <= 20; ++i) {
            upd(tr[i], mod(-pre[n], i + 1), 1);
        }
    }

    return 0;
}