字典树：1707. 与数组中元素的最大异或值

题目描述

给你一个由非负整数组成的数组 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.

提示：

• 1 <= nums.length, queries.length <= 105
• queries[i].length == 2
• 0 <= nums[j], xi, mi <= 109

思路

在做本题之前，建议先尝试解决 字典树：421. 数组中两个数的最大异或值。

由于全部询问已经给出，我们不一定要按顺序回答询问，而是按照 m_i 从小到大的顺序回答。

首先将数组 nums 从小到大排序，将询问按照 m_i 的大小从小到大排序。

在回答每个询问前，将所有不超过 m_i 的 nums 中的元素插入字典序中，由于 nums 已经排好序，我们可以维护一个指向 nums 数组元素的下标 id，初始值为 0，每插入一个元素就将 id 加一。对于每个询问，我们可以不断插入满足 nums[id]≤m_i 的元素，直至不满足该条件或 id 指向了数组末尾。

此时字典树中的元素就是 nums 中所有不超过 m_i的元素，这样就转换成了字典树：421. 数组中两个数的最大异或值的问题。

代码实现时，由于 nums 元素不超过 10^9，为简单起见，可取 L=30，即 10^9 的二进制串的长度。此外，由于对询问排序会打乱原询问的顺序，而我们需要按照原询问的顺序返回答案，因此可以在排序前，对每个询问附加一个其在 queries 中的下标。

Java代码

class Solution {

    class Trie {
        Trie[] children = new Trie[2];
    }
    Trie root = new Trie();

    public int[] maximizeXor(int[] nums, int[][] queries) {
        int[] res = new int[queries.length];
        Arrays.sort(nums);                                        // 把nums从小到大排序
        int[][] newQue = new int[queries.length][3];
        for (int i = 0; i < queries.length; i++) {                // 后续要对queries进行排序，所以这儿先记录原先的位置
            newQue[i][0] = queries[i][0];
            newQue[i][1] = queries[i][1];
            newQue[i][2] = i;                                     // 原先在queries的位置
        }
        Arrays.sort(newQue, new Comparator<int[]>() {
            public int compare(int[] que1, int[] que2) {
                return que1[1] - que2[1];
            }
        });

        int id = 0;
        for(int i = 0; i < newQue.length; i++) {
            int MAX = 0;
            int index = newQue[i][2];
            if(nums[0] > newQue[i][1]) {                          // 如果当前值 比nums[0] 最小值还小，说明不存在 
                res[index] = -1;
                continue;
            }
            for (int j = id; j < nums.length && nums[j] <= newQue[i][1]; j++) {   // 每次添加所有比当前值小的数到树中
                add(nums[j]);
                id++;
            }
            int x = getVal(newQue[i][0]);
            MAX = Math.max(MAX, newQue[i][0] ^ x);
            res[index] = MAX;
        }
        return res;
    }

    public void add(int num) {                                   // 字典树添加元素
        Trie node = root;
        for (int i = 29; i >= 0; i--) {
            int bit = (num >> i) & 1;
            if(node.children[bit] == null) {                    // 如果当前位为空，那么就要新建一个节点
                node.children[bit] = new Trie();
            }
            node = node.children[bit];
        }
    }

    public int getVal(int num) {                                // 获取字典树中与num进行异或运算的结果最大的元素
        Trie node = root;
        int res = 0;
        for(int i = 29; i >= 0; i--) {
            int a = (num >> i) & 1;
            int b = 1 - a;
            if(node.children[b] != null) {              //如果当前位a==0，那么就要走1，如果1不存在，那就只能走0，毕竟要保证最后的值是在 nums 里面的；反之同理
                node = node.children[b];
                res |= (b << i);
            } else {
                node = node.children[a];
                res |= (a << i);
            }
        }
        return res;
    }    
}

复杂度分析

时间复杂度：O(n)
空间复杂度：O(n)