【LeetCode】421. 数组中两个数的最大异或值（哈希集合，字典树，详细图文解释）

题目

地址

分析

题目要求 O(N)时间复杂度，下面会讨论两种典型的 O(N) 复杂度解法。

1. 利用哈希集合存储按位前缀。
2. 利用字典树存储按位前缀。

这两种解法背后的思想是一样的，都是先将整数转化成二进制形式，再从最左侧的比特位开始逐一处理来构建最大异或值。两个方法的不同点在于采用了不同的数据结构来存储按位前缀。第一个方法在给定的测试集下执行速度更快，但第二种方法更加普适，更加简单。

异或运算的性质

解决这个问题，我们首先需要利用异或运算的一个性质：

如果 a ^ b = c 成立，那么a ^ c = b 与 b ^ c = a 均成立。

即 如果有三个数，满足其中两个数的异或值等于另一个值，那么这三个数的顺序可以任意调换。

（说明：利用这条性质，可以不使用第 3 个变量而交换两个变量的值。）

• 那么如何理解这个性质呢？因为异或运算其实就是 二进制下不进位的加法，你不妨自己举几个例子，在草稿纸上验证一下。

如何应用到本题？

这道题找最大值的思路是这样的：因为两两异或可以得到一个值，在所有的两两异或得到的值中，一定有一个最大值，我们推测这个最大值应该是什么样的？即根据“最大值”的存在性解题（一定存在）。在这里要强调一下：

我们只用关心这个最大的异或值需要满足什么性质，进而推出这个最大值是什么，而不必关心这个异或值是由哪两个数得来的。

（上面这句话很重要，如果读者一开始看不明白下面的思考，不妨多看几遍我上面写的这句话。）

于是有如下思考：

1、二进制下，我们希望一个数尽可能大，即希望越高位上越能够出现“1”，这样这个数就是所求的最大数，这是贪心算法的思想。

2、于是，我们可以从最高位开始，到最低位，首先假设高位是 “1”，把这 n 个数全部遍历一遍，看看这一位是不是真的可以是“1”，否则这一位就得是“0”，判断的依据是上面“异或运算的性质”，即下面的第 3 点；

3、如果 a ^ b = max 成立 ，max 表示当前得到的“最大值”，那么一定有 max ^ b = a 成立。我们可以先假设当前数位上的值为 “1”，再把当前得到的数与这个 n 个数的 前缀（因为是从高位到低位看，所以称为“前缀”）进行异或运算，放在一个哈希表中，再依次把所有 前缀 与这个假设的“最大值”进行异或以后得到的结果放到哈希表里查询一下，如果查得到，就说明这个数位上可以是“1”，否则就只能是 0（看起来很晕，可以看代码理解）。

一种极端的情况是，这 n 个数在某一个数位上全部是 0 ，那么任意两个数异或以后都只能是 0，那么假设当前数位是 1 这件事情就不成立。

4、如何得到前缀，可以用掩码（mask），掩码可以进行如下构造，将掩码与原数依次进行 “与” 运算，就能得到前缀。

10000000000000000000000000000000
11000000000000000000000000000000
11100000000000000000000000000000
11110000000000000000000000000000
11111000000000000000000000000000
11111100000000000000000000000000
11111110000000000000000000000000
11111111000000000000000000000000
11111111100000000000000000000000
11111111110000000000000000000000
11111111111000000000000000000000
11111111111100000000000000000000
11111111111110000000000000000000
11111111111111000000000000000000
11111111111111100000000000000000
11111111111111110000000000000000
11111111111111111000000000000000
11111111111111111100000000000000
11111111111111111110000000000000
11111111111111111111000000000000
11111111111111111111100000000000
11111111111111111111110000000000
11111111111111111111111000000000
11111111111111111111111100000000
11111111111111111111111110000000
11111111111111111111111111000000
11111111111111111111111111100000
11111111111111111111111111110000
11111111111111111111111111111000
11111111111111111111111111111100
11111111111111111111111111111110
11111111111111111111111111111111

图片解释

以题目中的数组 [3, 10, 5, 25, 2, 8] 为例，下面讲解这个最大的两两异或值是如何得到的，这里为了方便演示，只展示一个数二进制的低 8 位。

方法一：利用哈希集合存储按位前缀

参考代码：

import java.util.HashSet;
import java.util.Set;

public class Solution {

    // 先确定高位，再确定低位（有点贪心算法的意思），才能保证这道题的最大性质
    // 一位接着一位去确定这个数位的大小
    // 利用性质： a ^ b = c ，则 a ^ c = b，且 b ^ c = a

    public int findMaximumXOR(int[] nums) {
        int res = 0;
        int mask = 0;
        for (int i = 30; i >= 0; i--) {
            // 注意点1：注意保留前缀的方法，mask 是这样得来的
            // 用异或也是可以的 mask = mask ^ (1 << i);
            mask = mask | (1 << i);

            // System.out.println(Integer.toBinaryString(mask));
            Set<Integer> set = new HashSet<>();
            for (int num : nums) {
                // 注意点2：这里使用 & ，保留前缀的意思（从高位到低位）
                set.add(num & mask);
            }

            // 这里先假定第 n 位为 1 ，前 n-1 位 res 为之前迭代求得
            int temp = res | (1 << i);
            for (Integer prefix : set) {
                if (set.contains(prefix ^ temp)) {
                    res = temp;
                    break;
                }
            }
        }
        return res;
    }
}

复杂度分析：

• 时间复杂度：O(N)，把整个数组看了 31 次，即 O(31N) = O(N)。
• 空间复杂度：O(n)，这里的 n是哈希表的长度，具体长度是多少，与输入的规模、扩容策略、负载因子和冲突策略等有关。例如 Java 在 JDK 1.8 以后，当哈希值冲突的时候，先把冲突的元素放在单链表上，当冲突的键值大于 8 的时候，再转成红黑树。

方法二：逐位字典树

为什么哈希集合不适合用来存储按位前缀？

对于那些一定不能得到最终解的路径可以通过剪枝来舍弃，但是用哈希集合来存储按位前缀是没法做剪枝优化的。举个例子，两次异或操作之后为了得到 (11***)_2(11∗∗∗)2，显然只能让 25 和 最左侧为 0000 前缀的数字（2，3， 5）组合。

$3 = (00011)_2$

$10 = (01010)_2$

$5 = (00101)_2$

$25 = (11001)_2$

$2 = (00010)_2$

$8 = (01000)_2$

因此，在计算第三位比特的时候，我们就没有必要计算所有可能的按位前缀组合了。光看前两位就知道一些组合已经不能得到最大异或值了。

$3 = (000**)_2$

$10 = (010**)_2$

$5 = (001**)_2$

$25 = (110**)_2$

$2 = (000**)_2$

$8 = (010**)_2$

为了方便剪枝，我们要采用一种类树的存储结构。

按位字典树：这是什么？怎么构建？

假设数组为 [3, 10, 5, 25, 2]，据此来构建按位字典树。

$3 = (00011)_2$

$10 = (01010)_2$

$5 = (00101)_2$

$25 = (11001)_2$

$2 = (00010)_2$

字典树中每条根节点到叶节点的路径都代表了 nums 中的一个整数（二进制形式），举个例子，0 -> 0 -> 0 -> 1 -> 1 表示 3。与之前的方法一样，所有二进制的长度都为 LL，其中 $L = 1 + [log_2 M]$，这里 M 为 nums 中的最大数值。显然字典树的深度也为 L，同时叶子节点也都在同一层。

字典树非常适合用来存储整数的二进制形式，例如存储 2（00010） 和 3（00011），其中 5 个比特位中有 4 个比特位都是相同的。字典树的构建方式也很简单，就是嵌套哈希表。在每一步，判断要增加的孩子节点（0，1）是否已经存在，如果存在就直接访问该孩子节点。如果不存在，需要先新增孩子节点再访问。

TrieNode trie = new TrieNode();
for (String num : strNums) {
  TrieNode node = trie;
  for (Character bit : num.toCharArray()) { 
    if (node.children.containsKey(bit)) {
      node = node.children.get(bit);
    } else {
      TrieNode newNode = new TrieNode();
      node.children.put(bit, newNode);
      node = newNode;
    }
  }  
}

字典树中给定数的最大异或值

为了最大化异或值，需要在每一步找到当前比特值的互补比特值。下图展示了 25 在每一步要怎么走才能得到最大异或值：

实现方式也很简单：

• 如果当前比特值存在互补比特值，访问具有互补比特值的孩子节点，并在异或值最右侧附加一个 1。
• 如果不存在，直接访问具有当前比特值的孩子节点，并在异或值最右侧附加一个 0。

TrieNode trie = new TrieNode();
for (String num : strNums) {
  TrieNode xorNode = trie;
  int currXor = 0;
  for (Character bit : num.toCharArray()) {
    Character toggledBit = bit == '1' ? '0' : '1';
    if (xorNode.children.containsKey(toggledBit)) {
      currXor = (currXor << 1) | 1;
      xorNode = xorNode.children.get(toggledBit);
    } else {
      currXor = currXor << 1;
      xorNode = xorNode.children.get(bit);
    }
  }
}

算法

算法结构如下所示：

• 在按位字典树中插入数字。
• 找到插入数字在字典树中所能得到的最大异或值。

算法的具体实现如下所示：

• 将所有数字转化成二进制形式。
• 将数字的二进制形式加入字典树，同时计算该数字在字典树中所能得到的最大异或值。再用该数字的最大异或值尝试性更新 max_xor。
• 返回 max_xor。

class TrieNode {
  HashMap<Character, TrieNode> children = new HashMap<Character, TrieNode>();
  public TrieNode() {}
}

class Solution {
  public int findMaximumXOR(int[] nums) {
    // Compute length L of max number in a binary representation
    int maxNum = nums[0];
    for(int num : nums) maxNum = Math.max(maxNum, num);
    int L = (Integer.toBinaryString(maxNum)).length();

    // zero left-padding to ensure L bits for each number
    int n = nums.length, bitmask = 1 << L;
    String [] strNums = new String[n];
    for(int i = 0; i < n; ++i) {
      strNums[i] = Integer.toBinaryString(bitmask | nums[i]).substring(1);
    }

    TrieNode trie = new TrieNode();
    int maxXor = 0;
    for (String num : strNums) {
      TrieNode node = trie, xorNode = trie;
      int currXor = 0;
      for (Character bit : num.toCharArray()) {
        // insert new number in trie  
        if (node.children.containsKey(bit)) {
          node = node.children.get(bit);
        } else {
          TrieNode newNode = new TrieNode();
          node.children.put(bit, newNode);
          node = newNode;
        }

        // compute max xor of that new number 
        // with all previously inserted
        Character toggledBit = bit == '1' ? '0' : '1';
        if (xorNode.children.containsKey(toggledBit)) {
          currXor = (currXor << 1) | 1;
          xorNode = xorNode.children.get(toggledBit);
        } else {
          currXor = currXor << 1;
          xorNode = xorNode.children.get(bit);
        }
      }
      maxXor = Math.max(maxXor, currXor);
    }

    return maxXor;
  }
}

复杂度分析

• 时间复杂度：O(N)。在字典树插入一个数的时间复杂度为 O(L)O(L)，找到一个数的最大异或值时间复杂度也为 O(L)O(L)。其中 $L = 1 + [log_2 M]$，M 为数组中的最大数值，这里可以当做一个常量。因此最终时间复杂度为 O(N)。
• 空间复杂度：O(1)。维护字典树最多需要$ O(2^L) = O(M)$ 的空间，但由于输入的限制，这里的 L 和 M 可以当做常数。