给定一个整数数组，你必须找到两个异或最大的元素。
有一种简单的方法——只需选择每个元素并与其他元素进行异或运算，然后比较结果以找到对。
除此之外，还有什么高效的算法吗？
【问题讨论】：
标签： arrays algorithm bit-manipulation xor
我想我有一个O(n lg U) 算法，其中U 是最大的数字。这个想法类似于 user949300 的想法，但更详细一些。
直觉如下。当您对两个数字进行异或运算时，要获得最大值，您希望在可能的最高位置有一个1，然后在这个位置有一个1 的配对中，您需要一个配对1 在下一个可能的最高位置，等等。
所以算法如下。首先在数字中的任意位置找到最高的1 位（您可以通过对每个n 数字执行O(lg U) 来及时做到这一点O(n lg U)）。现在，将数组分成两部分 - 一个在该位中具有 1 的数字和在该位中具有 0 的组。任何最佳解决方案都必须将第一个位置的带有1 的数字与该位置的带有0 的数字组合起来，因为这会使1 位尽可能高。任何其他配对都有一个0。
现在，我们希望递归地从1 和0 组中找到具有最高1 的数字对。为此，将这两组分为四组：
11 开头的数字
10 开头的数字
01 开头的数字
00 开头的数字
如果11 和00 组或10 和01 组中有任何数字，它们的异或将是理想的（以11 开头）。因此，如果这些组对中的任何一个不为空，则从这些组递归计算理想解决方案，然后返回这些子问题解决方案的最大值。否则，如果两个组都是空的，这意味着所有数字的第二个位置必须具有相同的数字。因此，以1 开头的数字和以0 开头的数字的最佳异或最终会抵消下一个第二位，所以我们应该只看第三位。
这给出了以下递归算法，从由 MSB 划分的两组数字开始，给出答案：
1 和组0 以及位索引i：
1 组中的（唯一）数与 0 组中的（唯一）数的异或。11、10、01 和 00。11 和组00 不为空，则递归查找从位i + 1 开始的这两个组的最大异或。10 和组01 不为空，则递归查找这两个组的最大异或，从位i + 1 开始。i 位置必须具有相同的位，因此返回通过查看组1 和0 上的位i + 1 找到的最大对。要开始该算法，您实际上可以将初始组中的数字分成两组 - MSB 1 的数字和 MSB 0 的数字。然后，您使用两组数字对上述算法进行递归调用。
例如，考虑数字5 1 4 3 0 2。这些有表示
101 001 100 011 000 010
我们首先将它们分成1 组和0 组：
101 100
001 011 000 010
现在，我们应用上述算法。我们将其分为11、10、01 和 00 组：
11:
10: 101 100
01: 011 010
00: 000 001
现在，我们无法将任何11 元素与00 元素配对，因此我们只对10 和01 组进行递归。这意味着我们构建了100、101、010 和011 组：
101: 101
100: 100
011: 011
010: 010
现在我们只剩下一个元素的桶了，我们可以检查101和010（给出111）和100和011（给出@ 987654396@)。这两种方法都适用，因此我们得到最佳答案是7。
让我们考虑一下这个算法的运行时间。请注意，最大递归深度为O(lg U)，因为数字中只有O(log U) 位。在树的每一层，每个数字恰好出现在一个递归调用中，并且每个递归调用确实与0 和1 组中的数字总数成正比，因为我们需要按它们的分布来分配它们位。因此，递归树中有O(log U) 个层级，每个层级都做O(n) 的工作，总工作量为O(n log U)。
希望这会有所帮助！这是一个很棒的问题！
【讨论】：
这可以使用Trie 以O(NlogN) 的时间复杂度解决。
arr[0, 1, ..... N] 的每个arr[i] 元素
arr[i] 可能的最大异或值。我们知道不同类型位的异或（0 ^ 1 或1 ^ 0）总是1。因此，在查询每个位的过程中，尝试遍历持有相反位的节点。这将使特定位 1 导致 xor 值最大化。如果没有位相反的节点，则只遍历同位节点。arr[i]插入trie。对于N 元素，我们需要对每个元素进行一次查询（O(logN)）和一次插入（O(logN)）。所以整体时间复杂度为O(NlogN)。
您可以在in this thread 找到很好的图解说明。
这是上述算法的 C++ 实现：
const static int SIZE = 2;
const static int MSB = 30;
class trie {
private:
struct trieNode {
trieNode* children[SIZE];
trieNode() {
for(int i = 0; i < SIZE; ++i) {
children[i] = nullptr;
}
}
~trieNode() {
for(int i = 0; i < SIZE; ++i) {
delete children[i];
children[i] = nullptr;
}
}
};
trieNode* root;
public:
trie(): root(new trieNode()) {
}
~trie() {
delete root;
root = nullptr;
}
void insert(int key) {
trieNode* pCrawl = root;
for(int i = MSB; i >= 0; --i) {
bool bit = (bool)(key & (1 << i));
if(!pCrawl->children[bit]) {
pCrawl->children[bit] = new trieNode();
}
pCrawl = pCrawl->children[bit];
}
}
int query(int key, int& otherKey) {
int Xor = 0;
trieNode *pCrawl = root;
for(int i = MSB; i >= 0; --i) {
bool bit = (bool)(key & (1 << i));
if(pCrawl->children[!bit]) {
pCrawl = pCrawl->children[!bit];
Xor |= (1 << i);
if(!bit) {
otherKey |= (1 << i);
} else {
otherKey &= ~(1 << i);
}
} else {
if(bit) {
otherKey |= (1 << i);
} else {
otherKey &= ~(1 << i);
}
pCrawl = pCrawl->children[bit];
}
}
return Xor;
}
};
pair<int, int> findMaximumXorElements(vector<int>& arr) {
int n = arr.size();
int maxXor = 0;
pair<int, int> result;
if(n < 2) return result;
trie* Trie = new trie();
Trie->insert(0); // insert 0 initially otherwise first query won't find node to traverse
for(int i = 0; i < n; i++) {
int elem = 0;
int curr = Trie->query(arr[i], elem);
if(curr > maxXor) {
maxXor = curr;
result = {arr[i], elem};
}
Trie->insert(arr[i]);
}
delete Trie;
return result;
}
【讨论】：
C 步骤（整数编码的宽度，在我们的示例中为32），所以我们的复杂性不应该像N * C插入步骤加上N * C 查询步骤，结果为O(2 * (N * C)) <=> O(N)?
忽略符号位，其中一个值必须是设置了最高有效位的值之一。 除非所有值都设置了该位，在这种情况下，您将转到未在所有值中设置的下一个最高有效位。因此，您可以通过查看 HSB 来减少第一个值的可能性。例如，如果可能性是
0x100000
0x100ABC
0x001ABC
0x000ABC
最大对的第一个值必须是 0x100000 或 0x10ABCD。
@internal 服务器错误我认为最小的不一定是正确的。我没有减少第二个值的好主意。可能的第一个值列表中不是的任何值。在我的示例中，0x001ABC 或 0x000ABC。
【讨论】：
一个非常有趣的问题！ 这是我的想法：
如果 a 和 b 到达叶子，则应该指向两个具有“非常少”相同位的数字。
我只是编造了这个算法，不知道它是否正确或如何证明它。但是它应该在 O(n) 的运行时间内。
【讨论】：
创建一个递归函数，将两个整数列表 A 和 B 作为其参数。作为它的返回值，它返回两个整数，一个来自 A，一个来自 B，这两个整数的 XOR 最大化。如果所有整数都为 0，则返回 (0,0)。否则，该函数会进行一些处理并递归调用自身两次，但使用较小的整数。在其中一个递归调用中，它考虑从列表 A 中获取一个整数来为位 k 提供 1，而在另一个调用中，它考虑从列表 B 中获取一个整数来为位 k 提供 1。
我现在没有时间填写详细信息，但也许这足以看到答案？另外，我不确定运行时间是否会比 N^2 更好，但可能会。
【讨论】：
我们可以在 O(n) 时间内找到最大数量，然后循环遍历数组，对每个元素进行异或。假设异或运算成本为 O(1)，我们可以在 O(n) 时间内找到两个数的最大异或。
【讨论】：