A. Water Buying (CodeForces 1118A)

• 标签：贪心、数学

题目大意

需要购买 $n$ 升水。1 升装售价 $a$，2 升装售价 $b$。求最少需要花费多少钱。

算法思路

比较两种购买方式的单价性价比：

• 买两瓶 1 升装需要花费 $2a$。
• 若 $2a \le b$，说明 1 升装更划算或价格相同，全部购买 1 升装即可，花费为 $n \times a$。
• 若 $2a > b$，说明 2 升装更划算。应尽可能多买 2 升装，即购买 $\lfloor n / 2 \rfloor$ 瓶 2 升装；若 $n$ 为奇数，剩下的 1 升补买 1 瓶 1 升装，总花费为： $$\lfloor n / 2 \rfloor \times b + (n \bmod 2) \times a$$

综合两式，直接取最小值即可： $$\min\Big(n \times a,; \lfloor n / 2 \rfloor \times b + (n \bmod 2) \times a\Big)$$

复杂度分析

• 时间复杂度：$O(1)$。
• 空间复杂度：$O(1)$。

参考代码

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

void solve() {
    int n, a, b;
    cin >> n >> a >> b;
    int x = n * a;
    int y = (n % 2) * a + (n / 2) * b;
    cout << min(x, y) << "\n";
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

B. Edge Deletion (CodeForces 1076D)

• 标签：图论、Dijkstra、最短路树 (SPT)、贪心

题目大意

给定包含 $n$ 个点、$m$ 条边的带正权连通无向图。现在需要保留至多 $k$ 条边。 定义“好点”：如果某个节点在保留边构成的新图中的最短路（以 1 为源点）与原图完全相等，则称该点为好点。 要求最大化好点的数量，输出保留的边数及保留边的编号。

算法思路

1. 从源点 1 出发的所有单源最短路径构成一棵最短路树（Shortest Path Tree, SPT），最多包含 $n-1$ 条边。
2. 观察性质：只要一个点 $v$ 到根节点 1 的路径上的所有树边都被保留，$v$ 在新图中的最短距离就一定与原图一致，因此 $v$ 成为好点。
3. 任何一条保留的边最多只能将 1 个新的好点连接到以 1 为根的连通分量中。因此保留 $k$ 条边最多产生 $1 + \min(k, n-1)$ 个好点。
4. 我们在运行 Dijkstra 算法时，当一个点 $u$ 被从优先队列中取出（距离确定）时，记录将其松弛的树边 parent_edge[u]。
5. 按照节点被确定的先后顺序（即距离递增的拓扑/BFS顺序），依次选取前 $\min(k, n-1)$ 条树边。因为边权为正，后确定的节点的祖先必已确定，这样保证了被选取的边始终构成包含根节点 1 的一棵连通子树。

复杂度分析

• 时间复杂度：$O(m \log n)$。
• 空间复杂度：$O(n + m)$。

参考代码

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

struct Edge {
    int to;
    long long w;
    int id;
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m, k;
    if (!(cin >> n >> m >> k)) return 0;

    vector<vector<Edge>> adj(n + 1);
    for (int i = 1; i <= m; i++) {
        int u, v;
        long long w;
        cin >> u >> v >> w;
        adj[u].push_back({v, w, i});
        adj[v].push_back({u, w, i});
    }

    const long long INF = 1e18;
    vector<long long> dist(n + 1, INF);
    vector<int> parent_edge(n + 1, 0);
    vector<bool> vis(n + 1, false);

    priority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<pair<long long, int>>> pq;
    dist[1] = 0;
    pq.push({0, 1});

    vector<int> ans;

    while (!pq.empty()) {
        auto [d, u] = pq.top();
        pq.pop();

        if (vis[u]) continue;
        vis[u] = true;

        if (u != 1 && (int)ans.size() < k) {
            ans.push_back(parent_edge[u]);
        }

        for (const auto& edge : adj[u]) {
            int v = edge.to;
            if (d + edge.w < dist[v]) {
                dist[v] = d + edge.w;
                parent_edge[v] = edge.id;
                pq.push({dist[v], v});
            }
        }
    }

    cout << ans.size() << "\n";
    for (int i = 0; i < (int)ans.size(); i++) {
        cout << ans[i] << (i + 1 == (int)ans.size() ? "" : " ");
    }
    cout << "\n";

    return 0;
}

C. Basketball Exercise (CodeForces 1195C)

• 标签：动态规划、线性 DP

题目大意

两排学生，每排各 $n$ 人。第 1 排学生身高为 $h_{1,i}$，第 2 排学生身高为 $h_{2,i}$。 要求挑选若干学生组成篮球队，选出的学生列号必须严格单调递增，且队伍所在的行必须严格交替。求选出学生的身高总和最大值。

算法思路

定义状态：

• $f[i][0]$：在前 $i$ 列中选人，且第 $i$ 列选第 1 排的最大身高总和；
• $f[i][1]$：在前 $i$ 列中选人，且第 $i$ 列选第 2 排的最大身高总和。

转移方程： $$f[i][0] = \max(f[i-1][1], f[i-2][1]) + h_{1, i}$$ $$f[i][1] = \max(f[i-1][0], f[i-2][0]) + h_{2, i}$$

最终答案为 $\max(f[n][0], f[n][1], f[n-1][0], f[n-1][1])$。

复杂度分析

• 时间复杂度：$O(n)$。
• 空间复杂度：$O(n)$。

参考代码

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

int f[100005][2], a[100005][2];

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    if (!(cin >> n)) return 0;

    for (int i = 1; i <= n; i++) cin >> a[i][0];
    for (int i = 1; i <= n; i++) cin >> a[i][1];

    f[1][0] = a[1][0];
    f[1][1] = a[1][1];

    for (int i = 2; i <= n; i++) {
        for (int j = 0; j <= 1; j++) {
            f[i][j] = max(f[i - 1][1 - j], f[i - 2][1 - j]) + a[i][j];
        }
    }

    cout << max({f[n - 1][0], f[n - 1][1], f[n][0], f[n][1]}) << "\n";
    return 0;
}

D. Tree Painting (CodeForces 1187E)

• 标签：树形 DP、换根 DP

题目大意

给定包含 $n$ 个节点的无向树，初始所有点均为白色。

• 第 1 步：任选一个白点染黑，得分加上该点所在的白色连通块大小（初始为 $n$）。
• 第 $i$ 步（$2 \le i \le n$）：选取一个与已有黑点相邻的白点染黑，得分加上该点染色前所在白色连通块的大小。 求将全部节点染黑所能获得的最大总得分。

算法思路

1. 当以 $r$ 为初始根节点时，总得分为所有节点以 $r$ 为根时的子树大小之和： $$dp[r] = \sum_{u=1}^n \text{size}_r(u)$$
2. 换根 DP 转移：
   • 第一次 DFS：选 1 为根，统计子树大小 $sz[u]$ 以及 $dp[1] = \sum sz[u]$。
   • 第二次 DFS：根由 $u$ 移动到子节点 $v$： $$dp[v] = dp[u] - sz[v] + (n - sz[v]) = dp[u] + n - 2 \cdot sz[v]$$
3. 遍历所有节点求 $\max dp[u]$。

复杂度分析

• 时间复杂度：$O(n)$。
• 空间复杂度：$O(n)$。

参考代码

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    if (!(cin >> n)) return 0;

    vector<vector<int>> adj(n + 1);
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    vector<long long> sz(n + 1, 0);
    vector<long long> dp(n + 1, 0);

    auto dfs1 = [&](auto& self, int u, int p) -> void {
        sz[u] = 1;
        for (int v : adj[u]) {
            if (v == p) continue;
            self(self, v, u);
            sz[u] += sz[v];
        }
        dp[1] += sz[u];
    };

    dfs1(dfs1, 1, 0);

    long long max_ans = dp[1];

    auto dfs2 = [&](auto& self, int u, int p) -> void {
        for (int v : adj[u]) {
            if (v == p) continue;
            dp[v] = dp[u] - sz[v] + (n - sz[v]);
            max_ans = max(max_ans, dp[v]);
            self(self, v, u);
        }
    };

    dfs2(dfs2, 1, 0);

    cout << max_ans << "\n";
    return 0;
}

E. LCM (CodeForces 1068B)

• 标签：数论、因数分解

题目大意

给定正整数 $b$（$b \le 10^{10}$），对于所有正整数 $a$，求 $\frac{\text{LCM}(a, b)}{a}$ 的不同取值个数。

算法思路

由公式： $$\frac{\text{LCM}(a, b)}{a} = \frac{b}{\gcd(a, b)}$$ 由于 $\gcd(a, b)$ 可以取遍 $b$ 的每一个正因数，因此不同取值的个数严格等于 $b$ 的因数个数 $d(b)$。在 $O(\sqrt{b})$ 内枚举因数即可。

复杂度分析

• 时间复杂度：$O(\sqrt{b})$。
• 空间复杂度：$O(1)$。

参考代码

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

signed main() {
    int b;
    if (cin >> b) {
        int ans = 0;
        for (int i = 1; i * i <= b; ++i) {
            if (b % i == 0) {
                ans += (i * i == b ? 1 : 2);
            }
        }
        cout << ans << "\n";
    }
    return 0;
}

F. Easy Problem (CodeForces 1096D)

• 标签：动态规划、字符串

题目大意

给定长度为 $n$ 的字符串 $s$。删除第 $i$ 个字符的花费为 $a_i$。求最小的花费，使得剩余的字符串中不包含子序列 "hard"。

算法思路

维护前缀串消除各个前缀子序列的代价：

• $dp[0]$：无子序列 "h"；
• $dp[1]$：无子序列 "ha"；
• $dp[2]$：无子序列 "har"；
• $dp[3]$：无子序列 "hard"。

转移：

• $s[i] == \text{'h'}$：$dp[0] \gets dp[0] + a_i$；
• $s[i] == \text{'a'}$：$dp[1] \gets \min(dp[1] + a_i, dp[0])$；
• $s[i] == \text{'r'}$：$dp[2] \gets \min(dp[2] + a_i, dp[1])$；
• $s[i] == \text{'d'}$：$dp[3] \gets \min(dp[3] + a_i, dp[2])$。

答案为 $dp[3]$。

复杂度分析

• 时间复杂度：$O(n)$。
• 空间复杂度：$O(1)$。

参考代码

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    if (!(cin >> n)) return 0;

    string s;
    cin >> s;

    vector<long long> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];

    vector<long long> dp(4, 0);

    for (int i = 0; i < n; i++) {
        if (s[i] == 'h') {
            dp[0] += a[i];
        } else if (s[i] == 'a') {
            dp[1] = min(dp[1] + a[i], dp[0]);
        } else if (s[i] == 'r') {
            dp[2] = min(dp[2] + a[i], dp[1]);
        } else if (s[i] == 'd') {
            dp[3] = min(dp[3] + a[i], dp[2]);
        }
    }

    cout << dp[3] << "\n";
    return 0;
}

G. Catch Overflow! (CodeForces 1175B)

• 标签：栈模拟、大数防溢出

题目大意

初始 $x = 0$。程序包含 for n、end、add。add 会累加外层循环的连乘倍数。若 $x \ge 2^{32}$ 输出 OVERFLOW!!!，否则输出最终的 $x$。

算法思路

使用栈维护循环倍数的前缀积。遇到乘积超过 $2^{32}$ 时截断为 $2^{32}$ 防止越界。执行 add 时累加，若 $\ge 2^{32}$ 立即输出 OVERFLOW!!!。

复杂度分析

• 时间复杂度：$O(l)$。
• 空间复杂度：$O(l)$。

参考代码

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

const int max_ = 1LL << 32;

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int l;
    if (!(cin >> l)) return 0;

    vector<int> stk;
    stk.reserve(l + 1);
    stk.push_back(1);

    int ans = 0;
    for (int i = 0; i < l; i++) {
        string s;
        cin >> s;
        if (s == "for") {
            int n;
            cin >> n;
            stk.push_back(min(max_, stk.back() * n));
        } else if (s == "end") {
            stk.pop_back();
        } else if (s == "add") {
            ans += stk.back();
            if (ans >= max_) {
                cout << "OVERFLOW!!!\n";
                return 0;
            }
        }
    }

    cout << ans << "\n";
    return 0;
}

H. Magic Ship (CodeForces 1117C)

• 标签：二分答案、前缀和、曼哈顿距离

题目大意

起点 $(x_1, y_1)$，终点 $(x_2, y_2)$。风力周期为 $n$。每天风力推船 1 步，船自主可走 1 步或不动。求最少到达天数；无法到达输出 -1。

算法思路

二分天数 $mid$。计算前 $mid$ 天风力位移 $(wx, wy)$，风力吹到点为 $(cur_x, cur_y) = (x_1 + wx, y_1 + wy)$。 可行充要条件： $$|x_2 - cur_x| + |y_2 - cur_y| \le mid$$ 二分上界取 $10^{15}$。

复杂度分析

• 时间复杂度：$O(n + \log(\text{max_ans}))$。
• 空间复杂度：$O(n)$。

参考代码

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

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int x1, y1, x2, y2;
    if (!(cin >> x1 >> y1 >> x2 >> y2)) return 0;

    int n;
    string s;
    cin >> n >> s;

    if (x1 == x2 && y1 == y2) {
        cout << 0 << "\n";
        return 0;
    }

    vector<int> px(n + 1, 0), py(n + 1, 0);
    for (int i = 0; i < n; i++) {
        px[i + 1] = px[i];
        py[i + 1] = py[i];
        if (s[i] == 'U') py[i + 1]++;
        else if (s[i] == 'D') py[i + 1]--;
        else if (s[i] == 'L') px[i + 1]--;
        else if (s[i] == 'R') px[i + 1]++;
    }

    int l = 1, r = 1e15;
    int ans = -1;

    auto check = [&](int mid) -> bool {
        int cnt = mid / n, rem = mid % n;
        int wx = cnt * px[n] + px[rem], wy = cnt * py[n] + py[rem];
        int cur_x = x1 + wx, cur_y = y1 + wy;
        return mid >= llabs(x2 - cur_x) + llabs(y2 - cur_y);
    };

    while (l <= r) {
        int mid = l + (r - l) / 2;
        if (check(mid)) {
            ans = mid;
            r = mid - 1;
        } else {
            l = mid + 1;
        }
    }

    cout << ans << "\n";
    return 0;
}

I. Maximal Continuous Rest (CodeForces 1141B)

• 标签：环形数组、断环成链

题目大意

给定循环 0/1 数组，求最长连续 1 的长度。

算法思路

数组倍长为 $2n$，统计最大连续 1 计数，与 $n$ 取 $\min$。

复杂度分析

• 时间复杂度：$O(n)$。
• 空间复杂度：$O(n)$。

参考代码

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    if (!(cin >> n)) return 0;

    vector<int> a(2 * n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        a[i + n] = a[i];
    }

    int ans = 0, cur = 0;
    for (int i = 0; i < 2 * n; i++) {
        if (a[i] == 1) {
            cur++;
            ans = max(ans, cur);
        } else {
            cur = 0;
        }
    }

    ans = min(ans, n);
    cout << ans << "\n";
    return 0;
}

J. Cow and Snacks (CodeForces 1209D)

• 标签：图论、连通分量、并查集

题目大意

$n$ 种零食，$k$ 位客人。每人喜好两种零食，若都已被拿走则伤心。求最少伤心人数。

算法思路

大小为 $V$ 的连通块最多满足 $V-1$ 人。使用并查集合并，每次成功合并说明增加 1 位满意客人。答案为 $k - \text{成功合并次数}$。

复杂度分析

• 时间复杂度：$O(k \cdot \alpha(n))$。
• 空间复杂度：$O(n)$。

参考代码

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

struct DSU {
    vector<int> parent;
    DSU(int n) : parent(n + 1) {
        iota(parent.begin(), parent.end(), 0);
    }
    int find(int i) {
        if (parent[i] == i)
            return i;
        return parent[i] = find(parent[i]);
    }
    bool unite(int i, int j) {
        int root_i = find(i);
        int root_j = find(j);
        if (root_i != root_j) {
            parent[root_i] = root_j;
            return true;
        }
        return false;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, k;
    if (!(cin >> n >> k)) return 0;

    DSU dsu(n);
    int happy = 0;

    for (int i = 0; i < k; i++) {
        int x, y;
        cin >> x >> y;
        if (dsu.unite(x, y)) {
            happy++;
        }
    }

    int sad = k - happy;
    cout << sad << "\n";
    return 0;
}

K. Array and Segments (Hard version) (CodeForces 1108E2)

• 标签：线段树、扫描线、贪心

题目大意

选择区间子集执行 $-1$，最大化 $\max(a') - \min(a')$。

算法思路

若最小值在 $p$ 取得，最优策略是选择全部覆盖 $p$ 的区间。扫描线遍历 $p \in [1, n]$，在 $l_j$ 时线段树区间 $-1$，在 $r_j$ 之后区间 $+1$，全局维护 $\max - \min$。

复杂度分析

• 时间复杂度：$O(n + m \log n)$。
• 空间复杂度：$O(n + m)$。

参考代码

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

struct Node {
    int mn, mx, lazy;
};

const int INF = 1e9;
vector<Node> tree;
vector<int> a;

void push_up(int u) {
    tree[u].mn = min(tree[u << 1].mn, tree[u << 1 | 1].mn);
    tree[u].mx = max(tree[u << 1].mx, tree[u << 1 | 1].mx);
}

void apply(int u, int val) {
    tree[u].mn += val;
    tree[u].mx += val;
    tree[u].lazy += val;
}

void push_down(int u) {
    if (tree[u].lazy != 0) {
        apply(u << 1, tree[u].lazy);
        apply(u << 1 | 1, tree[u].lazy);
        tree[u].lazy = 0;
    }
}

void build(int u, int l, int r) {
    tree[u].lazy = 0;
    if (l == r) {
        tree[u].mn = a[l];
        tree[u].mx = a[l];
        return;
    }
    int mid = l + (r - l) / 2;
    build(u << 1, l, mid);
    build(u << 1 | 1, mid + 1, r);
    push_up(u);
}

void update(int u, int l, int r, int ql, int qr, int val) {
    if (ql <= l && r <= qr) {
        apply(u, val);
        return;
    }
    push_down(u);
    int mid = l + (r - l) / 2;
    if (ql <= mid) update(u << 1, l, mid, ql, qr, val);
    if (qr > mid) update(u << 1 | 1, mid + 1, r, ql, qr, val);
    push_up(u);
}

struct Segment {
    int l, r, id;
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m;
    if (!(cin >> n >> m)) return 0;

    a.resize(n + 1);
    int orig_min = INF, orig_max = -INF;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        orig_min = min(orig_min, a[i]);
        orig_max = max(orig_max, a[i]);
    }

    vector<Segment> segs(m);
    vector<vector<int>> start_at(n + 2), end_at(n + 2);
    for (int i = 0; i < m; i++) {
        cin >> segs[i].l >> segs[i].r;
        segs[i].id = i + 1;
        start_at[segs[i].l].push_back(i);
        end_at[segs[i].r].push_back(i);
    }

    tree.resize(4 * (n + 1));
    build(1, 1, n);

    int best_diff = orig_max - orig_min;
    int best_p = 0;

    for (int p = 1; p <= n; p++) {
        for (int idx : start_at[p]) {
            update(1, 1, n, segs[idx].l, segs[idx].r, -1);
        }

        int cur_diff = tree[1].mx - tree[1].mn;
        if (cur_diff > best_diff) {
            best_diff = cur_diff;
            best_p = p;
        }

        for (int idx : end_at[p]) {
            update(1, 1, n, segs[idx].l, segs[idx].r, 1);
        }
    }

    vector<int> chosen;
    if (best_p > 0) {
        for (int i = 0; i < m; i++) {
            if (segs[i].l <= best_p && best_p <= segs[i].r) {
                chosen.push_back(segs[i].id);
            }
        }
    }

    cout << best_diff << "\n";
    cout << chosen.size() << "\n";
    for (int i = 0; i < (int)chosen.size(); i++) {
        cout << chosen[i] << (i + 1 == (int)chosen.size() ? "" : " ");
    }
    cout << "\n";

    return 0;
}

L. Vasya and Triangle (CodeForces 1030D)

• 标签：数论、构造、几何

题目大意

在 $n \times m$ 区域构造三角形使面积为 $\frac{nm}{k}$。

算法思路

必要条件 $k \mid 2nm$。构造直角边 $xy = \frac{2nm}{k}$。

• 若 $k$ 为偶数：$x = \frac{n}{\gcd(n, k/2)}$，$y = \frac{m}{(k/2)/\gcd(n, k/2)}$；
• 若 $k$ 为奇数：求出基础值后将因子 2 乘给不超过边界的一维。

复杂度分析

• 时间复杂度：$O(\log(\min(n, k)))$。
• 空间复杂度：$O(1)$。

参考代码

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

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m, k;
    if (!(cin >> n >> m >> k)) return 0;

    if ((2 * n * m) % k != 0) {
        cout << "NO\n";
        return 0;
    }

    cout << "YES\n";
    int x, y;
    if (k % 2 == 0) {
        int kp = k / 2;
        int g = gcd(n, kp);
        x = n / g;
        y = m / (kp / g);
    } else {
        int g = gcd(n, k);
        x = n / g;
        y = m / (k / g);
        if (2 * x <= n) {
            x *= 2;
        } else {
            y *= 2;
        }
    }

    cout << "0 0\n";
    cout << x << " 0\n";
    cout << "0 " << y << "\n";

    return 0;
}

M. Two Arrays and Sum of Functions (CodeForces 1165E)

• 标签：贡献法、排序不等式

题目大意

重排数组 $b$，求 $\sum_{1 \le l \le r \le n} \sum_{i=l}^r a_i b_i$ 模 998244353 的最大值。

算法思路

计算贡献 $w_i = a_i \cdot i \cdot (n - i + 1)$。 排序不等式：将 $w$ 和 $b$ 均升序排序后对应相乘。注意排序前切勿取模。

复杂度分析

• 时间复杂度：$O(n \log n)$。
• 空间复杂度：$O(n)$。

参考代码

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    if (!(cin >> n)) return 0;

    vector<long long> a(n), b(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    for (int i = 0; i < n; i++) cin >> b[i];

    vector<long long> w(n);
    for (int i = 0; i < n; i++) {
        w[i] = a[i] * (i + 1LL) * (n - i);
    }

    sort(w.begin(), w.end());
    sort(b.begin(), b.end());

    const long long MOD = 998244353;
    long long ans = 0;
    for (int i = 0; i < n; i++) {
        long long term = (w[i] % MOD) * (b[i] % MOD) % MOD;
        ans = (ans + term) % MOD;
    }

    cout << ans << "\n";
    return 0;
}

注：本文部分内容由AI润色排版

异或，英文为 Exclusive OR，通常简写为 XOR。在 C++ 中，异或运算符写作 ^。

对于刚接触算法竞赛的选手来说，异或题经常给人一种“技巧性很强”的感觉：有些题只需要把所有数字异或一遍，有些题却需要使用 01 Trie、可持久化数据结构，甚至线性基和快速沃尔什变换。

这些题目看似相差很远，实际上可以归纳为三类基本思想：

1. 抵消性：相同数字异或两次会消失；
2. 按位决策：异或值的大小首先取决于最高不同位；
3. 线性结构：异或可以看作二元域上的向量加法。

一、异或的基本性质

1. 单个位上的异或

对于两个二进制位，异或运算规则如下：

也就是说：

两个二进制位相同时结果为 $0$，不同时结果为 $1$。

例如：

  101101
^ 011001
--------
  110100

在 C++ 中可以写成：

int c = a ^ b;

2. 基本代数性质

异或满足以下性质：

$$ a\oplus 0=a $$

$$ a\oplus a=0 $$

$$ a\oplus b=b\oplus a $$

$$ (a\oplus b)\oplus c=a\oplus(b\oplus c) $$

由此可以得到：

$$ a\oplus b\oplus b=a $$

这意味着异或的逆运算仍然是异或。

若：

$$ a\oplus b=c $$

那么：

$$ a\oplus c=b $$

以及：

$$ b\oplus c=a $$

因此，在处理异或等式时，也可以进行类似“移项”的操作，只不过移项后使用的仍然是异或。

3. 相同元素的抵消

考虑下面的序列：

3, 5, 3, 7, 5

将所有数字异或：

$$ 3\oplus5\oplus3\oplus7\oplus5 $$

利用交换律和结合律重新排列：

$$ (3\oplus3)\oplus(5\oplus5)\oplus7 $$

相同数字两两抵消：

$$ 0\oplus0\oplus7=7 $$

因此，如果一个数组中只有一个数字出现奇数次，其余数字都出现偶数次，那么将所有元素异或起来，就能得到那个特殊数字。

int answer = 0;

for (int x : a) {
    answer ^= x;
}

时间复杂度为 $O(n)$，额外空间复杂度为 $O(1)$。

参考与练习

• OI Wiki：位操作
• 洛谷 P1469 找筷子：利用相同元素的抵消性质寻找未配对元素。
• Codeforces 276D — Little Girl and Maximum XOR：从最高不同位分析区间中的最大异或值。

二、异或方程与计数

考虑下面的问题：

给定一个数组 $a$ 和整数 $k$，统计有多少对下标 $i<j$，满足

$$ a_i\oplus a_j=k $$

利用异或移项：

$$ a_i\oplus a_j=k $$

两边同时异或 $a_j$，得到：

$$ a_i=a_j\oplus k $$

因此，当我们扫描到 $a_j$ 时，只需要查询此前出现过多少个：

$$ a_j\oplus k $$

可以使用哈希表记录每个数字已经出现的次数：

long long countPairs(const vector<int>& a, int k) {
    unordered_map<int, long long> count;
    long long answer = 0;

    for (int x : a) {
        answer += count[x ^ k];
        ++count[x];
    }

    return answer;
}

这里必须先查询，再插入当前元素。

因为哈希表中只应保存当前位置之前的元素，这样才能保证统计的是满足 $i<j$ 的数对。

这种问题可以总结为：

当题目给出了两个数的异或结果，并要求寻找另一个数时，可以优先尝试使用异或移项。

参考与练习

• Codeforces 742B — Arpa’s obvious problem and Mehrdad’s terrible solution：异或方程与数对计数的经典应用。

三、前缀异或

1. 区间异或

定义前缀异或：

$$ pre_i=a_1\oplus a_2\oplus\cdots\oplus a_i $$

并令：

$$ pre_0=0 $$

那么区间 $[l,r]$ 的异或值为：

$$ a_l\oplus a_{l+1}\oplus\cdots\oplus a_r =pre_r\oplus pre_{l-1} $$

展开右侧：

$$ pre_r\oplus pre_{l-1} $$

$$

(a_1\oplus\cdots\oplus a_{l-1}\oplus a_l\oplus\cdots\oplus a_r) \oplus (a_1\oplus\cdots\oplus a_{l-1}) $$

前面的公共部分各出现两次，全部抵消，最终只剩下：

$$ a_l\oplus a_{l+1}\oplus\cdots\oplus a_r $$

代码与前缀和非常相似：

vector<int> prefixXor(n + 1, 0);

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

int rangeXor = prefixXor[r] ^ prefixXor[l - 1];

2. 统计异或值为 $k$ 的子数组

现在希望统计满足：

$$ a_l\oplus a_{l+1}\oplus\cdots\oplus a_r=k $$

的区间数量。

利用前缀异或：

$$ pre_r\oplus pre_{l-1}=k $$

移项可得：

$$ pre_{l-1}=pre_r\oplus k $$

因此，在扫描到当前前缀异或值 $pre_r$ 时，只需要统计此前出现过多少次：

$$ pre_r\oplus k $$

long long countSubarraysXorK(const vector<int>& a, int k) {
    unordered_map<int, long long> count;

    // 空前缀 pre[0] = 0
    count[0] = 1;

    int prefix = 0;
    long long answer = 0;

    for (int x : a) {
        prefix ^= x;

        answer += count[prefix ^ k];
        ++count[prefix];
    }

    return answer;
}

初始化：

count[0] = 1;

表示空前缀。

如果从数组开头到当前位置的异或值本身等于 $k$，那么：

$$ prefix\oplus k=0 $$

此时空前缀应当作为一个合法选择被统计。

3. 树上的路径异或

下面讨论的是无向带权树，路径的权值定义为路径上所有边权的异或值。

任选一个节点作为根，定义：

$$ dis_u $$

表示根节点到节点 $u$ 的路径异或值。

如果边 $(u,v)$ 的权值为 $w$，那么在 DFS 过程中：

dis[v] = dis[u] ^ w;

对于任意两个节点 $u,v$，它们之间路径的异或值为：

$$ path(u,v)=dis_u\oplus dis_v $$

原因是根到 $u$ 与根到 $v$ 的公共部分会出现两次，从而相互抵消。

这和数组中的：

$$ pre_r\oplus pre_{l-1} $$

本质上是同一种结构。

参考与练习

• OI Wiki：位操作
• 洛谷 P2420 让我们异或吧：无向带权树上的路径异或查询。

四、01 Trie 与异或极值

1. 最大异或问题

考虑经典问题：

给定若干非负整数，对于一个查询值 $x$，寻找集合中的一个数 $y$，使得 $x\oplus y$ 最大。

整数的大小首先由二进制表示中的最高不同位决定，因此应从最高位向最低位考虑。

假设 $x$ 当前位为 $0$：

• 如果 $y$ 当前位为 $1$，这一位的异或结果为 $1$；
• 如果 $y$ 当前位为 $0$，这一位的异或结果为 $0$。

为了使最终答案尽可能大，应优先选择当前位与 $x$ 不同的数字。

可以把所有数字的二进制表示插入一棵 Trie：

• 每一层对应一个二进制位；
• child[0] 表示这一位是 $0$；
• child[1] 表示这一位是 $1$；
• 查询时优先进入与 $x$ 当前位相反的分支。

2. 基础模板

下面的模板假设输入为不超过 $2^{31}-1$ 的非负整数，因此处理第 $30$ 位到第 $0$ 位。

实际使用时，应根据题目数据范围调整最高位。

struct BinaryTrie {
    static constexpr int MAX_BIT = 30;

    struct Node {
        int child[2] = {-1, -1};
        int count = 0;
    };

    vector<Node> trie;

    BinaryTrie() {
        trie.emplace_back();
    }

    bool empty() const {
        return trie[0].count == 0;
    }

    void insert(int x) {
        int node = 0;
        ++trie[node].count;

        for (int bit = MAX_BIT; bit >= 0; --bit) {
            int value = (x >> bit) & 1;

            if (trie[node].child[value] == -1) {
                trie[node].child[value] =
                    static_cast<int>(trie.size());
                trie.emplace_back();
            }

            node = trie[node].child[value];
            ++trie[node].count;
        }
    }

    int queryMaxXor(int x) const {
        // 调用前必须保证 Trie 非空
        int node = 0;
        int answer = 0;

        for (int bit = MAX_BIT; bit >= 0; --bit) {
            int value = (x >> bit) & 1;
            int preferred = value ^ 1;

            int preferredChild = trie[node].child[preferred];

            if (preferredChild != -1 &&
                trie[preferredChild].count > 0) {
                answer |= 1 << bit;
                node = preferredChild;
            } else {
                int fallbackChild = trie[node].child[value];
                node = fallbackChild;
            }
        }

        return answer;
    }
};

每次插入或查询都会经过固定数量的二进制位，因此复杂度为：

$$ O(B) $$

其中 $B$ 是处理的二进制位数。

处理前缀异或问题时，通常需要在开始查询前先插入前缀异或值 $0$。

3. 动态插入与删除

如果题目要求支持删除，不能直接删除 Trie 节点，因为同一个前缀可能被多个数字共享。

正确做法是在每个节点维护经过该节点的数字数量。

void add(int x, int delta) {
    int node = 0;
    trie[node].count += delta;

    for (int bit = MAX_BIT; bit >= 0; --bit) {
        int value = (x >> bit) & 1;

        if (trie[node].child[value] == -1) {
            trie[node].child[value] =
                static_cast<int>(trie.size());
            trie.emplace_back();
        }

        node = trie[node].child[value];
        trie[node].count += delta;
    }
}

其中：

• delta = 1 表示插入；
• delta = -1 表示删除。

执行删除操作时，必须保证集合中至少存在一个对应的数字。如果题目不保证这一点，还需要额外维护每个完整数字的出现次数。

4. 最大异或与最小异或

求最大异或时，应优先选择相反位：

preferred = bit ^ 1

求最小异或时，应优先选择相同位：

preferred = bit

两种操作的本质相同，区别只在于每一层优先选择哪个分支。

参考与练习

• OI Wiki：字典树 Trie
• 洛谷 P4551 最长异或路径：树上前缀异或与最大异或查询。
• Codeforces 706D — Vasiliy’s Multiset：动态插入、删除与最大异或查询。
• Codeforces 923C — Perfect Security：可删除多重集合中的最小异或匹配。

五、Trie 上统计 $x\oplus y<k$

最大异或查询只需要决定当前位应优先选择相同还是不同。

但有些题目要求统计：

$$ x\oplus y<k $$

此时需要同时考虑 $x$、$y$ 和 $k$ 的当前位。

令：

$$ z=x\oplus y $$

问题转化为在 Trie 中统计满足：

$$ z<k $$

的 $y$ 的数量。

仍然从最高位向最低位处理。

1. 当 $k$ 当前位为 $0$

如果此前各位仍然与 $k$ 相等，那么为了保证结果不超过 $k$，$z$ 当前位只能为 $0$。

因此，$y$ 当前位必须与 $x$ 当前位相同，并继续向低位判断。

2. 当 $k$ 当前位为 $1$

此时有两种选择。

如果令 $z$ 当前位为 $0$，那么答案在这一位已经严格小于 $k$，后续所有位都可以任意选择。因此，可以直接加入对应子树中的所有元素数量。

如果令 $z$ 当前位为 $1$，当前前缀仍然与 $k$ 相等，需要继续向低位判断。

long long countLess(int x, int k) const {
    int node = 0;
    long long answer = 0;

    for (int bit = MAX_BIT; bit >= 0; --bit) {
        if (node == -1) {
            break;
        }

        int xb = (x >> bit) & 1;
        int kb = (k >> bit) & 1;

        if (kb == 1) {
            // 令 xor 当前位为 0，此后一定小于 k
            int same = trie[node].child[xb];

            if (same != -1) {
                answer += trie[same].count;
            }

            // 令 xor 当前位为 1，继续保持前缀相等
            node = trie[node].child[xb ^ 1];
        } else {
            // xor 当前位只能为 0
            node = trie[node].child[xb];
        }
    }

    return answer;
}

如果题目要求统计：

$$ x\oplus y\geq k $$

可以先计算集合中的元素总数，再减去满足：

$$ x\oplus y<k $$

的元素数量。

参考与练习

• OI Wiki：字典树 Trie
• Codeforces 817E — Choosing The Commander：动态集合中的异或上界统计。
• Codeforces 665E — Beautiful Subarrays：前缀异或与 Trie 统计的结合。

六、可持久化 01 Trie

1. 普通 Trie 的局限

普通 Trie 可以回答：

在当前集合中，哪个数字与 $x$ 的异或值最大？

但是，如果查询变为：

只允许选择编号位于 $[l,r]$ 中的元素。

普通 Trie 就无法直接判断某个分支中是否存在编号属于目标区间的元素。

一种常见解决方法是：为每个前缀建立一个 Trie 版本。

2. 可持久化的基本思想

假设已经有表示前 $i-1$ 个元素的 Trie。

插入第 $i$ 个元素时：

• 不复制整棵 Trie；
• 只复制从根节点到该数字叶节点的路径；
• 没有变化的子树继续与旧版本共享。

如果每个数字有 $B$ 个二进制位，那么每次插入只会新增：

$$ O(B) $$

个节点。

因此，插入 $n$ 个数字的总空间复杂度约为：

$$ O(nB) $$

3. 区间查询与版本作差

设：

• root[r] 表示插入前 $r$ 个元素后的 Trie；
• root[l - 1] 表示插入前 $l-1$ 个元素后的 Trie。

某个节点在编号区间 $[l,r]$ 中的元素数量，可以通过两个版本的节点计数相减得到：

$$ count(root_r)-count(root_{l-1}) $$

查询最大异或时，仍然优先尝试相反位，但只有当该分支在两个版本之间的数量差大于零时，才能进入该分支。

这一思想与主席树查询区间信息时的“版本作差”非常相似。

4. P4735 中的前缀异或转化

设序列的前缀异或为：

$$ s_i=a_1\oplus a_2\oplus\cdots\oplus a_i $$

并令：

$$ s_0=0 $$

如果需要在 $p\in[l,r]$ 中选择一个位置，最大化：

$$ x\oplus a_p\oplus a_{p+1}\oplus\cdots\oplus a_n $$

那么：

$$ a_p\oplus a_{p+1}\oplus\cdots\oplus a_n =s_n\oplus s_{p-1} $$

原式变为：

$$ x\oplus s_n\oplus s_{p-1} $$

其中：

$$ x\oplus s_n $$

在当前查询中是固定值。

因此，问题变成：

在前缀编号 $p-1\in[l-1,r-1]$ 中选择一个 $s_{p-1}$，使它与固定值 $x\oplus s_n$ 的异或最大。

这正是带编号区间限制的最大异或查询，因此可以使用可持久化 01 Trie。

参考与练习

• OI Wiki：可持久化字典树
• 洛谷 P4735 最大异或和：动态添加元素与带编号范围的最大异或查询。

七、异或线性基

01 Trie 通常解决的是：

从集合中选择一个数，与给定值进行异或。

线性基解决的则是：

从集合中选择任意多个数，它们能够异或出哪些结果？

这是两类不同的问题。

1. 将整数看作向量

一个二进制整数可以看作由 $0$ 和 $1$ 构成的向量。

例如：

13 = 1101
10 = 1010
 7 = 0111

异或相当于每一位在模 $2$ 意义下相加：

0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 0

因此，异或可以看作二元域 $\mathrm{GF}(2)$ 上的向量加法。

线性基就是从原集合中选出一组线性无关向量，使原集合能够异或得到的所有结果，都可以由这组基向量表示。

2. 插入一个数字

维护：

basis[bit]

表示一个最高有效位为 bit 的基向量。

插入 $x$ 时，从最高位向最低位检查。

如果 $x$ 的第 bit 位为 $0$，无需处理。

如果该位为 $1$：

• 如果 basis[bit] 为空，就把 $x$ 放入该位置；
• 否则令 $x$ 异或 basis[bit]，消去当前最高位。

下面的代码假设输入不超过 $10^{18}$，因此处理第 $60$ 位到第 $0$ 位。

#include <cstdint>

using u64 = std::uint64_t;

struct LinearBasis {
    static constexpr int MAX_BIT = 60;

    u64 basis[MAX_BIT + 1]{};

    bool insert(u64 x) {
        for (int bit = MAX_BIT; bit >= 0; --bit) {
            if (((x >> bit) & 1ULL) == 0) {
                continue;
            }

            if (basis[bit] == 0) {
                basis[bit] = x;
                return true;
            }

            x ^= basis[bit];
        }

        return false;
    }
};

如果最终 $x=0$，说明原来的 $x$ 可以由已有基向量异或得到，因此它与已有向量线性相关。

3. 最大子集异或

从最高位向最低位尝试使用每个基向量：

u64 getMax() const {
    u64 answer = 0;

    for (int bit = MAX_BIT; bit >= 0; --bit) {
        answer = max(answer, answer ^ basis[bit]);
    }

    return answer;
}

这里仍然是在进行最高位贪心。

如果：

answer ^ basis[bit] > answer

说明加入该基向量后，答案在某个关键高位上变大，因此应保留这次变化。

4. 秩与方案数量

假设原集合共有 $n$ 个数字，将它们视为 $\mathrm{GF}(2)$ 上的向量，其秩为 $r$。

那么线性张成空间中一共有：

$$ 2^r $$

个不同的异或结果。

从所有 $2^n$ 个子集中选择一个子集，相当于从 $\mathrm{GF}(2)^n$ 中选择一组系数。

从系数空间到异或结果空间的线性映射，其核的维数为：

$$ n-r $$

因此，对于任意一个可以被表示的目标异或值，恰好有：

$$ 2^{n-r} $$

个子集能够得到该值，其中包括空集。

如果目标值不在线性张成空间中，则方案数为零。

参考与练习

• OI Wiki：线性基
• 洛谷 P3812【模板】线性基：最大子集异或。
• 洛谷 P3857 彩灯：利用线性基的秩计算可达到状态数量。
• 洛谷 P4570 元素：带权选择与线性无关性。
• Codeforces 959F — Mahmoud and Ehab and yet another xor task：可表示性、秩与方案数。

八、图上的异或与环空间

下面讨论的是无向带权图。起点与终点需要位于同一个连通分量中，路径权值定义为经过边权的异或值。

1. 树上的情况

在树上，两个节点之间的路径唯一。

定义根节点到 $u$ 的树上路径异或值为 $dis_u$，那么：

$$ path(u,v)=dis_u\oplus dis_v $$

只需要一次 DFS 就能计算所有 $dis$。

2. 一般图中的环

在一般图中，两个节点之间可能存在多条不同路径。

先任选一棵 DFS 生成树，并计算：

$$ dis_u $$

表示根节点到 $u$ 的树上路径异或值。

对于一条连接 $u,v$、边权为 $w$ 的非树边，它与生成树中的路径共同构成一个环，其异或值为：

$$ cycle=dis_u\oplus dis_v\oplus w $$

其中：

• $dis_u$ 表示根到 $u$ 的树上路径；
• $w$ 表示边 $(u,v)$；
• $dis_v$ 表示根到 $v$ 的树上路径。

这三部分共同组成一个闭合结构。

3. 环空间与路径调整

假设已经得到一条从起点 $s$ 到终点 $t$ 的基础路径，其异或值为：

$$ d=dis_s\oplus dis_t $$

图中的其他可行路线与这条基础路线之间的差异，可以由若干个环的异或组合产生。

因此，其他路径的异或值可以表示为：

$$ d\oplus c_1\oplus c_2\oplus\cdots $$

其中每个 $c_i$ 都来自图中的环空间。

将所有环异或值插入线性基之后，就可以使用线性基最大化或最小化基础路径异或值。

u64 maximize(u64 x) const {
    for (int bit = MAX_BIT; bit >= 0; --bit) {
        x = max(x, x ^ basis[bit]);
    }

    return x;
}

参考与练习

• OI Wiki：线性基
• 洛谷 P4151 最大 XOR 和路径：生成树、环异或与线性基。
• Codeforces 845G — Shortest Path Problem?：使用环空间处理最小异或路径。
• Codeforces 724G — Xor-matic Number of the Graph：环空间、线性基与按位贡献统计。

九、扩展：带位置的前缀线性基

普通线性基维护的是整个集合。

如果题目要求回答：

在区间 $[l,r]$ 中任选若干个数，求最大子集异或。

就需要限制基向量所使用元素的位置。

一种经典方法是给每个基向量附加一个时间戳：

basis[bit]：基向量的值
position[bit]：该基向量保留的最新位置

插入位于位置 $pos$ 的新元素时，从高位向低位消元。

如果新元素的位置比当前基向量记录的位置更靠后，就交换：

当前向量 x、当前时间戳 pos

与：

basis[bit]、position[bit]

这样可以在保持线性张成空间不变的前提下，让线性基尽量保留出现位置更靠后的向量。

查询区间左端点为 $l$ 时，只使用满足：

$$ position[bit]\geq l $$

的基向量。

需要注意的是，被换出的旧向量不能直接丢弃。它仍然可能包含低位上的有效信息，因此必须继续向更低位进行消元。

这一结构常被称为前缀线性基或带位置线性基，适合处理离线区间最大子集异或问题。

参考与练习

• OI Wiki：线性基
• Codeforces 1100F — Ivan and Burgers：区间最大子集异或。
• 洛谷 P3292 幸运数字：树上路径与线性基合并。

十、Nim 游戏与异或和

1. 游戏规则

经典 Nim 游戏有若干堆石子。

两名玩家轮流操作，每次可以：

• 选择任意一堆；
• 从中取走任意多个石子；
• 但至少取走一个。

无法继续操作的玩家失败。

设各堆石子数量为：

$$ a_1,a_2,\ldots,a_n $$

定义 Nim 和：

$$ S=a_1\oplus a_2\oplus\cdots\oplus a_n $$

结论为：

• 如果 $S=0$，当前玩家必败；
• 如果 $S\neq0$，当前玩家必胜。

2. 为什么 $S=0$ 是必败状态

假设当前 Nim 和为零。

玩家将某一堆 $a_i$ 修改为 $b_i$，且：

$$ a_i\neq b_i $$

新的异或和为：

$$ 0\oplus a_i\oplus b_i =a_i\oplus b_i $$

由于：

$$ a_i\neq b_i $$

因此：

$$ a_i\oplus b_i\neq0 $$

所以，从异或和为零的状态出发，无论如何操作，都会进入异或和非零的状态。

3. 为什么 $S\neq0$ 时可以变成零

设 $S$ 的最高有效位为第 $k$ 位。

因为 $S$ 的第 $k$ 位是 $1$，所以至少存在一堆 $a_i$，其第 $k$ 位也是 $1$。

令：

$$ b_i=a_i\oplus S $$

由于 $S$ 的最高有效位会把 $a_i$ 的第 $k$ 位从 $1$ 变成 $0$，因此：

$$ b_i<a_i $$

这是一次合法的减少操作。

操作后的 Nim 和为：

$$ S\oplus a_i\oplus b_i $$

代入：

$$ b_i=a_i\oplus S $$

得到：

$$ S\oplus a_i\oplus a_i\oplus S=0 $$

因此，异或和非零的玩家总能一步进入异或和为零的状态。

参考与练习

• OI Wiki：公平组合游戏
• 洛谷 P2197【模板】Nim 游戏：标准 Nim 游戏胜负判断。
• Codeforces 1383B — GameGame：从最高有效位分析异或博弈。

十一、扩展：XOR-FWT 与异或卷积

1. XOR 卷积

给定两个长度为 $n$ 的数组 $A,B$，定义：

$$ C_k=\sum_{i\oplus j=k}A_iB_j $$

这称为 XOR 卷积。

直接枚举所有 $i,j$ 的时间复杂度为：

$$ O(n^2) $$

当数组长度是 $2$ 的幂时，可以使用快速沃尔什变换，将复杂度优化为：

$$ O(n\log n) $$

2. XOR 蝶形

对于一对数 $x,y$，XOR-FWT 的蝶形变换为：

$$ (x,y)\longrightarrow(x+y,x-y) $$

完整模板如下：

void fwtXor(vector<long long>& a, bool inverse) {
    const int n = static_cast<int>(a.size());

    for (int len = 1; len < n; len <<= 1) {
        for (int start = 0; start < n; start += len << 1) {
            for (int i = 0; i < len; ++i) {
                const long long x = a[start + i];
                const long long y = a[start + i + len];

                a[start + i] = x + y;
                a[start + i + len] = x - y;
            }
        }
    }

    if (inverse) {
        for (long long& x : a) {
            x /= n;
        }
    }
}

卷积过程可以写成：

fwtXor(a, false);
fwtXor(b, false);

for (int i = 0; i < n; ++i) {
    a[i] *= b[i];
}

fwtXor(a, true);

最终数组 a 就是 XOR 卷积结果。

对 XOR-FWT 连续执行两次变换，会使每个元素整体乘以 $n$，因此逆变换需要除以 $n$。

在普通整数运算中，应确保最终结果能够整除 $n$，并注意中间值可能超过 long long 的范围。

在模意义下，不能直接使用整数除法，而应乘以：

$$ n^{-1}\pmod M $$

其中 $n^{-1}$ 是 $n$ 关于模数 $M$ 的乘法逆元。

参考资料

• OI Wiki：快速沃尔什变换