feat: add solutions to lc problem: No.1803

No.1803.Count Pairs With XOR in a Range

Author: yanglbme

solution/1800-1899/1803.Count Pairs With XOR in a Range/README.md

@@ -53,22 +53,253 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：0-1 字典树**
+
+对于这种区间 $[low, high]$ 统计的问题，我们可以考虑将其转换为统计 $[0, high]$ 和 $[0, low - 1]$ 的问题，然后相减即可得到答案。
+
+在这道题中，我们可以统计有多少数对的异或值小于 $high+1$，然后再统计有多少数对的异或值小于 $low$，相减的结果就是异或值在区间 $[low, high]$ 之间的数对数量。
+
+另外，对于数组异或计数问题，我们通常可以使用“0-1 字典树”来解决。
+
+在字典树中，我们定义两个函数，一个是 $insert(x)$，表示将数 $x$ 插入到字典树中；另一个是 $search(x, limit)$，表示在字典树中查找与 $x$ 异或值小于 $limit$ 的数对数量。
+
+对于 $insert(x)$ 函数，我们将数字 $x$ 按照二进制位从高到低的顺序，插入到“0-1 字典树”中，其中字典树的每个节点表示一个二进制位，每个节点有两个子节点，表示 $0$ 和 $1$。如果当前二进制位为 $0$，则插入到左子节点，否则插入到右子节点。然后将当前节点的计数值 $cnt$ 加 $1$。
+
+对于 $search(x, limit)$ 函数，我们从字典树的根节点 `node` 开始，遍历 $x$ 的二进制位，从高到低，记当前 $x$ 的二进制位的数为 $v$。
+
+-   如果当前 $limit$ 的二进制位为 $1$，此时我们可以直接将答案加上与 $x$ 的当前二进制位 $v$ 相同的子节点的计数值 $cnt$，然后将当前节点移动到与 $x$ 的当前二进制位 $v$ 不同的子节点，即 `node = node.children[v ^ 1]`。继续遍历下一位。
+-   如果当前 $limit$ 的二进制位为 $0$，此时我们只能将当前节点移动到与 $x$ 的当前二进制位 $v$ 相同的子节点，即 `node = node.children[v]`。继续遍历下一位。
+
+遍历完 $x$ 的二进制位后，返回答案。
+
+有了以上两个函数，我们就可以解决本题了。
+
+我们遍历数组 `nums`，对于每个数 $x$，我们先在字典树中查找与 $x$ 异或值小于 $high+1$ 的数对数量，然后在字典树中查找与 $x$ 异或值小于 $low$ 的数对数量，将两者的差值加到答案中。然后将 $x$ 插入到字典树中。继续遍历下一个数 $x$，直到遍历完数组 `nums`。最后返回答案即可。
+
+时间复杂度 $O(n \times \log M)$，空间复杂度 $O(n \times \log M)$。其中 $n$ 为数组 `nums` 的长度，而 $M$ 为数组 `nums` 中的最大值。本题中我们直接取 $\log M = 16$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Trie:
+    def __init__(self):
+        self.children = [None] * 2
+        self.cnt = 0
 
+    def insert(self, x):
+        node = self
+        for i in range(15, -1, -1):
+            v = x >> i & 1
+            if node.children[v] is None:
+                node.children[v] = Trie()
+            node = node.children[v]
+            node.cnt += 1
+
+    def search(self, x, limit):
+        node = self
+        ans = 0
+        for i in range(15, -1, -1):
+            v = x >> i & 1
+            if limit >> i & 1:
+                if node.children[v]:
+                    ans += node.children[v].cnt
+                if node.children[v ^ 1] is None:
+                    return ans
+                node = node.children[v ^ 1]
+            else:
+                if node.children[v] is None:
+                    return ans
+                node = node.children[v]
+        return ans
+
+
+class Solution:
+    def countPairs(self, nums: List[int], low: int, high: int) -> int:
+        ans = 0
+        tree = Trie()
+        for x in nums:
+            ans += tree.search(x, high + 1) - tree.search(x, low)
+            tree.insert(x)
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Trie {
+    private Trie[] children = new Trie[2];
+    private int cnt;
+
+    public void insert(int x) {
+        Trie node = this;
+        for (int i = 15; i >= 0; --i) {
+            int v = (x >> i) & 1;
+            if (node.children[v] == null) {
+                node.children[v] = new Trie();
+            }
+            node = node.children[v];
+            ++node.cnt;
+        }
+    }
+
+    public int search(int x, int limit) {
+        Trie node = this;
+        int ans = 0;
+        for (int i = 15; i >= 0; --i) {
+            int v = (x >> i) & 1;
+            if (((limit >> i) & 1) == 1) {
+                if (node.children[v] != null) {
+                    ans += node.children[v].cnt;
+                }
+                if (node.children[v ^ 1] == null) {
+                    return ans;
+                }
+                node = node.children[v ^ 1];
+            } else {
+                if (node.children[v] == null) {
+                    return ans;
+                }
+                node = node.children[v];
+            }
+        }
+        return ans;
+    }
+}
+
+class Solution {
+    public int countPairs(int[] nums, int low, int high) {
+        Trie trie = new Trie();
+        int ans = 0;
+        for (int x : nums) {
+            ans += trie.search(x, high + 1) - trie.search(x, low);
+            trie.insert(x);
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Trie {
+public:
+    Trie(): children(2), cnt(0) {}
+
+    void insert(int x) {
+        Trie* node = this;
+        for (int i = 15; ~i; --i) {
+            int v = x >> i & 1;
+            if (!node->children[v]) {
+                node->children[v] = new Trie();
+            }
+            node = node->children[v];
+            ++node->cnt;
+        }
+    }
+
+    int search(int x, int limit) {
+        Trie* node = this;
+        int ans = 0;
+        for (int i = 15; ~i; --i) {
+            int v = x >> i & 1;
+            if (limit >> i & 1) {
+                if (node->children[v]) {
+                    ans += node->children[v]->cnt;
+                }
+                if (!node->children[v ^ 1]) {
+                    return ans;
+                }
+                node = node->children[v ^ 1];
+            } else {
+                if (!node->children[v]) {
+                    return ans;
+                }
+                node = node->children[v];
+            }
+        }
+        return ans;
+    }
+
+private:
+    vector<Trie*> children;
+    int cnt;
+};
+
+class Solution {
+public:
+    int countPairs(vector<int>& nums, int low, int high) {
+        Trie* tree = new Trie();
+        int ans = 0;
+        for (int& x : nums) {
+            ans += tree->search(x, high + 1) - tree->search(x, low);
+            tree->insert(x);
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+type Trie struct {
+	children [2]*Trie
+	cnt      int
+}
+
+func newTrie() *Trie {
+	return &Trie{}
+}
+
+func (this *Trie) insert(x int) {
+	node := this
+	for i := 15; i >= 0; i-- {
+		v := (x >> i) & 1
+		if node.children[v] == nil {
+			node.children[v] = newTrie()
+		}
+		node = node.children[v]
+		node.cnt++
+	}
+}
+
+func (this *Trie) search(x, limit int) (ans int) {
+	node := this
+	for i := 15; i >= 0; i-- {
+		v := (x >> i) & 1
+		if (limit >> i & 1) == 1 {
+			if node.children[v] != nil {
+				ans += node.children[v].cnt
+			}
+			if node.children[v^1] == nil {
+				return
+			}
+			node = node.children[v^1]
+		} else {
+			if node.children[v] == nil {
+				return
+			}
+			node = node.children[v]
+		}
+	}
+	return
+}
 
+func countPairs(nums []int, low int, high int) (ans int) {
+	tree := newTrie()
+	for _, x := range nums {
+		ans += tree.search(x, high+1) - tree.search(x, low)
+		tree.insert(x)
+	}
+	return
+}
 ```
 
 ### **...**