范围 [L, R] 中最多 K 个元素的最小异或

介绍

给定一个整数范围 [L, R]，需要找出这个范围中最多 K 个元素的最小异或值。具体来说，需要在 L 和 R 中选择不超过 K 个整数，然后让它们两两异或，得到的最小结果即为所求。

这个问题可以利用数字前缀树（Trie）来解决。我们首先将 L 到 R 中的所有整数二进制表示按位拆分开来，然后构建数字前缀树。接着，我们在数字前缀树上进行一次深度优先搜索，寻找最多 K 个叶子节点。在进行搜索时，我们需要维护一个异或和，每到达一个叶子节点，就将异或和加入到一个有序序列中。最后，我们从序列中找出相邻两个元素的最小异或值即为所求。

实现

下面是一个用 C++ 实现的例子：

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

const int MAXN = 5e6 + 5;

int L, R, K;
int tot = 1;
int trie[MAXN][2], sum[MAXN], minv[MAXN];

void insert(int x) {
    int u = 1;
    for (int i = 30; i >= 0; i--) {
        int c = (x >> i) & 1;
        if (!trie[u][c]) trie[u][c] = ++tot;
        u = trie[u][c];
        sum[u]++;
    }
}

void dfs(int u, int now, vector<int>& v) {
    if (!u) return;
    if (sum[u] == 1) {
        v.push_back(now ^ minv[u]);
        return;
    }
    if (trie[u][0]) dfs(trie[u][0], now, v);
    if (trie[u][1]) dfs(trie[u][1], now ^ (1 << sum[u]), v);
}

bool check(int x) {
    memset(trie, 0, sizeof(trie));
    memset(sum, 0, sizeof(sum));
    tot = 1;
    insert(L - 1);
    for (int i = L; i <= R; i++) {
        insert(i);
        minv[tot] = i - L + 1;
    }
    vector<int> v;
    dfs(1, 0, v);
    sort(v.begin(), v.end());
    int ok = 0;
    for (int i = 0, j = 0; i < v.size(); i++) {
        while (j < v.size() && v[j] - v[i] <= x) j++;
        ok += j - i - 1;
        if (ok >= K) return true;
    }
    return false;
}

int main() {
    cin >> L >> R >> K;
    int l = 0, r = R - L, ans = -1;
    while (l <= r) {
        int mid = (l + r) >> 1;
        if (check(mid)) {
            ans = mid;
            r = mid - 1;
        } else {
            l = mid + 1;
        }
    }
    cout << ans << endl;
    return 0;
}

这里我们定义了 insert 函数来往数字前缀树中插入一个数字，同时维护了 sum 数组来记录每个节点的子节点个数，以便后续判断是否是叶子节点。dfs 函数表示对数字前缀树进行深度优先搜索，同时将每个叶子节点到根节点的异或和加入到 v 数组中。check 函数则表示二分搜索的过程，其中需要在数字前缀树中插入 L - 1 到 R 的所有数字，并维护一个 minv 数组来记录每个节点到根节点的异或和。最后，我们需要对 v 数组进行排序，并使用双指针方法寻找相邻两个元素的最小异或值是否小于等于当前的二分答案，以判断是否满足题目要求。

复杂度

该算法的时间复杂度为 O((R - L + 1) log (R - L + 1) log (2^31))，空间复杂度为 O((R - L + 1) log (2^31))。其中，前者是因为最多需要进行 O(log (R - L + 1)) 次深度优先搜索，而每次搜索的时间复杂度为 O((R - L + 1))，最后再进行一次排序和双指针搜索，而其时间复杂度均为 O((R - L + 1) log (R - L + 1))。后者是因为数字前缀树的节点个数最多为 O((R - L + 1) log (2^31))。