[字典树] 最大异或对(trie+贪心)

1. trie+贪心

Biu

很明显，暴力查找双重循环，时间复杂度 $O(n^2)$，大约 $10^{10}$ 次计算肯定超时了。可以利用 trie 来存所有数的数值，然后在进行查找的时候尽量选择当前位相异的路径走下去就行了，这也是一个贪心的思路，从高位开始，尽量选择相异的位 (异或为1) 的路径，所得到的异或结果肯定是最大的。

注意：

• trie 中所有的节点个数应该是 $10^5\ast 32$ 开 $4e^6$ 就行了，虽然实际上根本没这么多。

代码：

#include <iostream>

using namespace std;

const int N = 1e5+5, M = 4e6;   // M:trie树中节点长度，10w个数，一个数31位长，那么就最多是10w*31

int n;
int a[N];
int son[M][2], idx;  

// 正常字典树插入操作
void insert(int x) {
    int p = 0;
    for (int i = 30; i >= 0; --i) {
        int u = x >> i & 1;
        if (!son[p][u]) son[p][u] = ++idx;
        p = son[p][u];
    }
}

// 查询时，相当于尽量在树中查找接近~x的数
int query(int x) {
    int p = 0, res = 0;
    for (int i = 30; i >= 0; --i) {
        int u = x >> i & 1;
        if (son[p][!u]) { 	// 如果当前位取反存在
            p = son[p][!u]; // 走向不同方向，如果另外一个方向存在，则走到另外一个方向
            res = res * 2 + !u; // 动态计算当前路径的结果    
        }
        else {
            p = son[p][u];	// 只能走向同方向，这位异或为0
            res = res * 2 + u;
        }
    }
    return res;	// 返回最接近~x的数
}

int main() {
    cin >> n;
    for (int i = 0; i < n; ++i) cin >> a[i], insert(a[i]);
    
    int res = 0;
    for (int i = 0; i < n; ++i) res = max(res, a[i] ^ query(a[i]));
    cout << res << endl;
    return 0;
}

2. 简单优化

基于上述思想，简单优化插入、查找的顺序：

• 因为 $a\oplus b=c$ 等价于 $b\oplus a=c$，故我们在枚举当前数，执行查找的时不需要将所有的情况全部搜一遍，即不用搜索到第一个数后面的数，让它当做第二个异或数，因为当第一个数枚举到后面的时候，后面那个数会作为第一个数来进行异或，这样就重复搜索了，故我们可以一边遍历数组中所有数的时候一边对其进行插入和查找，而不是将所有数全部插入之后再进行查找
• 针对空树的情况，可以选择先插入再查找的顺序，这样就能保证树不为空，少处理一种边界情况

#include <iostream>

using namespace std;

const int N = 1e5+5, M = 4e6;   // M:trie树中节点长度，10w个数，一个数31位长，那么就最多是10w*31

int n;
int a[N];
int son[M][2], idx;  

// 正常字典树插入操作
void insert(int x) {
    int p = 0;
    for (int i = 30; i >= 0; --i) {
        int u = x >> i & 1;
        if (!son[p][u]) son[p][u] = ++idx;
        p = son[p][u];
    }
}

// 查询时，相当于尽量在树中查找接近~x的数
int query(int x) {
    int p = 0, res = 0;
    for (int i = 30; i >= 0; --i) {
        int u = x >> i & 1;
        if (son[p][!u]) { 	// 如果当前位取反存在
            p = son[p][!u]; // 走向不同方向，如果另外一个方向存在，则走到另外一个方向
            res = res * 2 + !u; // 动态计算当前路径的结果    
        }
        else {
            p = son[p][u];	// 只能走向同方向，这位异或为0
            res = res * 2 + u;
        }
    }
    return res;	// 返回最接近~x的数
}

int main() {
    cin >> n;
    for (int i = 0; i < n; ++i) cin >> a[i];
    
    int res = 0;
    for (int i = 0; i < n; ++i) {
        insert(a[i]);           // 先插入再查询，避免trie树中为空集的情况，少一种边界情况判断
        
        int t = query(a[i]);
        res = max(res, a[i] ^ t);
    }
    cout << res << endl;
    return 0;
}