LeetCode——1707. 与数组中元素的最大异或值(Maximum XOR With an Element From Array)[困难]——分析及代码（Java）

一、题目

给你一个由非负整数组成的数组 nums 。另有一个查询数组 queries ，其中 queries[i] = [xi, mi] 。

第 i 个查询的答案是 xi 和任何 nums 数组中不超过 mi 的元素按位异或（XOR）得到的最大值。换句话说，答案是 max(nums[j] XOR xi) ，其中所有 j 均满足 nums[j] <= mi 。如果 nums 中的所有元素都大于 mi，最终答案就是 -1 。

返回一个整数数组 answer 作为查询的答案，其中 answer.length == queries.length 且 answer[i] 是第 i 个查询的答案。

示例 1：

输入：nums = [0,1,2,3,4], queries = [[3,1],[1,3],[5,6]]
输出：[3,3,7]
解释：
1) 0 和 1 是仅有的两个不超过 1 的整数。0 XOR 3 = 3 而 1 XOR 3 = 2 。二者中的更大值是 3 。
2) 1 XOR 2 = 3.
3) 5 XOR 2 = 7.

示例 2：

输入：nums = [5,2,4,6,6,3], queries = [[12,4],[8,1],[6,3]]
输出：[15,-1,5]

提示：

• 1 <= nums.length, queries.length <= 10^5
• queries[i].length == 2
• 0 <= nums[j], xi, mi <= 10^9

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-xor-with-an-element-from-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析及代码

1. 字典树 + 离线查询

（1）思路

为求解最大异或值，可构造字典树，逐位进行计算。
为了确定不超过查询中 mi 的元素范围，可进一步结合离线求解方法，对 nums 数组和 queries 数组分别进行排序，只将符合要求的元素加入字典树，确保查询过程符合题意。

（2）代码

class Solution {
    public int[] maximizeXor(int[] nums, int[][] queries) {
        int n = nums.length, m = queries.length;
        Arrays.sort(nums);//nums从小到大排序
        int[][] newQueries = new int[m][3];//queries按mi从小到大排序，离线查询
        for (int i = 0; i < m; i++) {
            newQueries[i][0] = queries[i][0];
            newQueries[i][1] = queries[i][1];
            newQueries[i][2] = i;
        }
        Arrays.sort(newQueries, (q1, q2) -> q1[1] - q2[1]);
        
        int[] ans = new int[m];//查询答案
        int id = 0;//当前加入字典树的nums元素个数
        Trie root = new Trie();//构造字典树
        for (int i = 0; i < m; i++) {
            while (id < n && nums[id] <= newQueries[i][1])//将不超过mi的元素加入字典树
                root.insert(nums[id++]);
            if (id == 0)//字典树为空，答案为-1
                ans[newQueries[i][2]] = -1;
            else//查询得到最大异或值
                ans[newQueries[i][2]] = root.getMaxXor(newQueries[i][0]);

        }
        return ans;
    }
}

class Trie {
    static final int H = 30;//字典树高度
    Trie[] child = new Trie[2];//对应值为0、1的子节点

    //插入元素
    public void insert(int val) {
        Trie node = this;
        for (int i = H - 1; i >= 0; i--) {
            int bit = (val >> i) & 1;
            if (node.child[bit] == null)
                node.child[bit] = new Trie();
            node = node.child[bit];
        }
        return;
    }

    //查询最大异或值
    public int getMaxXor(int num) {
        Trie node = this;
        int ans = 0;
        for (int i = H - 1; i >= 0; i--) {
            int bit = (num >> i) & 1;
            if (node.child[1 - bit] != null) {
                ans |= (1 << i);
                node = node.child[1 - bit];
            } else
                node = node.child[bit];
        }
        return ans;
    }
}

（3）结果

执行用时 ：198 ms，在所有 Java 提交中击败了 79.10% 的用户；
内存消耗 ：151 MB，在所有 Java 提交中击败了 27.61% 的用户。

三、其他

暂无。