leetcode之数组中两个数的最大异或值（C++）

参考链接

1. https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/
2. https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/solution/shu-zu-zhong-liang-ge-shu-de-zui-da-yi-h-n9m9/

题目描述

给你一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，其中 0 ≤ i ≤ j < n 。

进阶：你可以在 O(n) 的时间解决这个问题吗？

解题思路

首先，暴力地两层循环是会超时的。可以从最高位到最低位依次确定最后结果，要结果最大，肯定想每一位都为1，如果不能就只有为0了。假设结果的前k-1位都已经确定了，要想确定当前第k位能否为1，就先假设第k位为1，然后将其与数组中的每个数的前k位异或，看异或值是否存在于所有数的前k位数构成的集合中。如果存在则第k为可以为1，否则为0。

另一种方法是用前缀树，即将每个数都保存在前缀树中，然后遍历数组中的每个树，从最高位开始，尽量找与其当前位相反的数（相反的数异或出来为1）。因为每次比较都会剪掉一部分树枝，所有复杂度还是比较低的。

代码

集合

class Solution {
public:
    int findMaximumXOR(vector<int>& nums) {
        int x = 0;
        for (int k = HIGH_BIT; k >= 0; --k) 
        {
            unordered_set<int> seen;
            for (int num: nums) 
            {
                seen.insert(num >> k);
            }

            int x_next = x << 1 + 1;
            bool found = false;

            for (int num: nums) 
            {
                if (seen.count(x_next ^ (num >> k))) 
                {
                    found = true;
                    break;
                }
            }

            if (found) 
            {
                x = x_next;
            }
            else 
            {
                x = x_next - 1;
            }
        }
        return x;
    }
};

前缀树

struct Trie {
    // 左子树指向表示 0 的子节点
    Trie* left = nullptr;
    // 右子树指向表示 1 的子节点
    Trie* right = nullptr;

    Trie() {}
};

class Solution {
public:
    Trie* root = new Trie();
    void add(int num) 
    {
        Trie* cur = root;
        for (int k = 30; k >= 0; --k) 
        {
            int bit = (num >> k) & 1;
            if (bit == 0) 
            {
                if (!cur->left) 
                {
                    cur->left = new Trie();
                }
                cur = cur->left;
            }
            else 
            {
                if (!cur->right) 
                {
                    cur->right = new Trie();
                }
                cur = cur->right;
            }
        }
    }

    int check(int num) 
    {
        Trie* cur = root;
        int x = 0;
        for (int k = 30; k >= 0; --k) 
        {
            int bit = (num >> k) & 1;
            if (bit == 0) 
            {
                // a_i 的第 k 个二进制位为 0，应当往表示 1 的子节点 right 走
                if (cur->right) 
                {
                    cur = cur->right;
                    x = (x << 1) + 1;
                }
                else 
                {
                    cur = cur->left;
                    x = x << 1;
                }
            }
            else 
            {
                // a_i 的第 k 个二进制位为 1，应当往表示 0 的子节点 left 走
                if (cur->left) 
                {
                    cur = cur->left;
                    x = (x << 1) + 1;
                }
                else 
                {
                    cur = cur->right;
                    x = x << 1;
                }
            }
        }
        return x;
    }

    int findMaximumXOR(vector<int>& nums) {
        int n = nums.size();
        int x = 0;
        for (int i = 1; i < n; ++i) 
        {
            // 将 nums[i-1] 放入字典树，此时 nums[0 .. i-1] 都在字典树中
            add(nums[i - 1]);
            // 将 nums[i] 看作 ai，找出最大的 x 更新答案
            x = max(x, check(nums[i]));
        }
        return x;
    }
};