8 ABC425 G 题解

ABC425 G

题面

给定两个正整数 \(N,M\) 以及一个长度为 \(N\) 的非负整数序列 \(A = A_1, A_2, ..., A_N\)。求

\[\sum_{x = 0}^{M - 1} \min_{1 \le i \le N} (x \oplus A_i) \]

\(1 \le N \le 2 \times 10^5\)

\(1 \le M \le 10^9\)

\(0 \le A_i \le 10^9\)

题解

首先，如果 \(M \le 10^5\)，那么是不是可以想到把 \(A\) 建成一棵 01trie，然后依次在 tire 上查询每个 \(x\)。

我们设 \(d\) 表示最多有多少层，也就是 \(\log V\)，其中 \(V\) 是值域，那么时间复杂度就是 \(O(Md)\)。

那么我们可以先建出一棵 trie，然后考虑如何处理 \(M \le 10^9\) 情况。

思考我们在 trie 上找异或最小值或者异或最大值，一般都是从上往下贪心的去遍历 trie，对于一个数是这样，对于一段连续的数，也是一样的，我们只关注最高位的情况。

所以我们可以将 \(0 \sim val\) 这一个区间的询问当成一个询问，然后对这个询问的情况进行分类讨论。

我们设当前询问为 \(0 \sim val\)，保证到第 \(k\) 层时 \(0 \sim val\) 二进制最高位的 \(1\) 处在第 \(k\) 位及以下，分两种情况来讨论：

• \(val < 2^k\)：也就说明 \(0 \sim val\) 中的所有数的第 \(k\) 位都是 \(0\)，尽量走左子树，如果走右子树，答案要加上 \(2^k \times (val + 1)\)。

• \(val \ge 2^k\)：这时要分成两段分别处理：

  \(0 \sim 2^k - 1\)：和上面的情况一样，尽量走左子树，否则答案加 \(2^k \times 2^k\)。

  \(2^k \sim val\)：这一段的第 \(k\) 位都是 \(1\)，所以应该尽量走右子树，否则答案加 \((val + 1) \times 2^k\)。这一段走到下一层的时候应该减去 \(2^k\)，因为要保证每次到下一层时二进制最高位的 \(1\) 处在第 \(k - 1\) 位及以下。

我们这样去处理的话，时间复杂度最坏还是 \(O(Md)\) 的，因为如果每层都分成两段，那么每到一层，询问个数都会翻倍，后面就会有 \(10^9\) 个询问，这是不能接受的。

要解决这个问题，就要用到一个神奇的 trick。

假如有两个询问，都是 \(0 \sim val\)，那么我们将两个询问合并，再记录一个 \(cnt\) 表示 \(0 \sim val\) 的询问出现了多少次。这样就能将时间复杂度降到 \(O(\frac d 2 \times 2^{d/2} \log V)\)。

考虑证明，我们将 dfs 的层分成上 15 层和下 15 层：

对于上 15 层，我们最多分出 \(2^{15}\) 个询问。

对于下 15 层，因为值域为 \(2^{15}\)，所以经过合并，最多也只有 \(2^{15}\) 个询问。

所以在每一层的询问个数都不会超过 \(2^{15}\) 个。

那么最后的时间复杂度就是 \(O(\frac d 2 \times 2^{d/2} \log V)\)，其中 \(\frac d 2\) 表示每层将 \(2^{d / 2}\) 个询问进行合并，排序的时间复杂度。（经过yyb大佬指点，这个排序的时间复杂度是可以通过实现消去的。因为只有拆分会影响顺序，通过维护两个队列，一个是拆分的，一个是未拆分的，这样两个队列都是有序的，合并的时候就能实现线性合并了）

关于实现细节，因为每个询问都是从 \(0\) 开始的，所以我们只记录右端点即可，在每个节点的询问可以用一个 vector 来储存。

code

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>using namespace std;const int N = 2e5 + 10, M = N * 30;typedef long long ll;
typedef pair <int, int> pii;int n, m;
int a[N], t[M][2], idx;
ll ans = 0;void insert (int x) {int p = 0;for (int i = 30; i >= 0; i --) {int ch = (x >> i) & 1;if (!t[p][ch]) t[p][ch] = ++ idx;p = t[p][ch];}
}void dfs (vector <pii> Q, int p, int k) {if (k < 0) return;vector <pii> ql, qr;sort (Q.begin (), Q.end ());for (int i = 0; i < (int)Q.size (); i ++) {while (i + 1 < (int)Q.size () && Q[i].first == Q[i + 1].first) {Q[i + 1].second += Q[i].second;i ++;}int val = Q[i].first, cnt = Q[i].second;if (val < (1 << k)) {if (t[p][0]) ql.emplace_back (val, cnt);else {ans += 1ll * (val + 1) * (1 << k) * cnt;qr.emplace_back (val, cnt);}} else {if (t[p][0]) ql.emplace_back ((1 << k) - 1, cnt);else {ans += 1ll * (1 << k) * (1 << k) * cnt;qr.emplace_back ((1 << k) - 1, cnt);}if (t[p][1]) qr.emplace_back (val - (1 << k), cnt);else {ans += 1ll * (val - (1 << k) + 1) * (1 << k) * cnt;ql.emplace_back (val - (1 << k), cnt);}}}if (t[p][0] && ql.size ()) dfs (ql, t[p][0], k - 1);if (t[p][1] && qr.size ()) dfs (qr, t[p][1], k - 1);
}int main () {cin >> n >> m;for (int i = 1; i <= n; i ++) {cin >> a[i];insert (a[i]);}vector <pii> Q;Q.emplace_back (m - 1, 1);dfs (Q, 0, 30);cout << ans << endl;return 0;
}