feat: add solutions to lc problem: No.2479

No.2479.Maximum XOR of Two Non-Overlapping Subtrees

Author: yanglbme

solution/2400-2499/2479.Maximum XOR of Two Non-Overlapping Subtrees/README.md

@@ -54,34 +54,326 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：递归 + 0-1 前缀树**
+
+我们先递归预处理出每个节点的子树和，记录在数组 $s$ 中。
+
+然后使用 0-1 前缀树维护遍历过的子树和，可以方便快速查找下一个子树和与之前的子树和的最大异或值。
+
+由于子树不能重叠，因此，我们先查询最大异或值，递归结束后，再将当前子树和插入到前缀树中。
+
+时间复杂度 $O(n \times log M)$，其中 $n$ 为节点个数，而 $M$ 为子树和的最大值。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Trie:
+    def __init__(self):
+        self.children = [None] * 2
+
+    def insert(self, x):
+        node = self
+        for i in range(47, -1, -1):
+            v = (x >> i) & 1
+            if node.children[v] is None:
+                node.children[v] = Trie()
+            node = node.children[v]
+
+    def search(self, x):
+        node = self
+        res = 0
+        for i in range(47, -1, -1):
+            v = (x >> i) & 1
+            if node is None:
+                return res
+            if node.children[v ^ 1]:
+                res = res << 1 | 1
+                node = node.children[v ^ 1]
+            else:
+                res <<= 1
+                node = node.children[v]
+        return res
+
+
+class Solution:
+    def maxXor(self, n: int, edges: List[List[int]], values: List[int]) -> int:
+        def dfs1(i, fa):
+            t = values[i]
+            for j in g[i]:
+                if j != fa:
+                    t += dfs1(j, i)
+            s[i] = t
+            return t
+
+        def dfs2(i, fa):
+            nonlocal ans
+            ans = max(ans, tree.search(s[i]))
+            for j in g[i]:
+                if j != fa:
+                    dfs2(j, i)
+            tree.insert(s[i])
+
+        g = defaultdict(list)
+        for a, b in edges:
+            g[a].append(b)
+            g[b].append(a)
+        s = [0] * n
+        dfs1(0, -1)
+        ans = 0
+        tree = Trie()
+        dfs2(0, -1)
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Trie {
+    Trie[] children = new Trie[2];
+
+    void insert(long x) {
+        Trie node = this;
+        for (int i = 47; i >= 0; --i) {
+            int v = (int) (x >> i) & 1;
+            if (node.children[v] == null) {
+                node.children[v] = new Trie();
+            }
+            node = node.children[v];
+        }
+    }
+
+    long search(long x) {
+        Trie node = this;
+        long res = 0;
+        for (int i = 47; i >= 0; --i) {
+            int v = (int) (x >> i) & 1;
+            if (node == null) {
+                return res;
+            }
+            if (node.children[v ^ 1] != null) {
+                res = res << 1 | 1;
+                node = node.children[v ^ 1];
+            } else {
+                res <<= 1;
+                node = node.children[v];
+            }
+        }
+        return res;
+    }
+}
+
+class Solution {
+    private List<Integer>[] g;
+    private int[] vals;
+    private long[] s;
+    private Trie tree;
+    private long ans;
+
+    public long maxXor(int n, int[][] edges, int[] values) {
+        g = new List[n];
+        s = new long[n];
+        vals = values;
+        for (int i = 0; i < n; ++i) {
+            g[i] = new ArrayList<>();
+        }
+        for (var e : edges) {
+            int a = e[0], b = e[1];
+            g[a].add(b);
+            g[b].add(a);
+        }
+        dfs1(0, -1);
+        tree = new Trie();
+        dfs2(0, -1);
+        return ans;
+    }
+
+    private void dfs2(int i, int fa) {
+        ans = Math.max(ans, tree.search(s[i]));
+        for (int j : g[i]) {
+            if (j != fa) {
+                dfs2(j, i);
+            }
+        }
+        tree.insert(s[i]);
+    }
+
+    private long dfs1(int i, int fa) {
+        long t = vals[i];
+        for (int j : g[i]) {
+            if (j != fa) {
+                t += dfs1(j, i);
+            }
+        }
+        s[i] = t;
+        return t;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+using ll = long long;
+
+class Trie {
+public:
+    vector<Trie*> children;
+    string v;
+    Trie()
+        : children(2) { }
+
+    void insert(ll x) {
+        Trie* node = this;
+        for (int i = 47; ~i; --i) {
+            int v = (x >> i) & 1;
+            if (!node->children[v]) node->children[v] = new Trie();
+            node = node->children[v];
+        }
+    }
+
+    ll search(ll x) {
+        Trie* node = this;
+        ll res = 0;
+        for (int i = 47; ~i; --i) {
+            if (!node) return res;
+            int v = (x >> i) & 1;
+            if (node->children[v ^ 1]) {
+                res = res << 1 | 1;
+                node = node->children[v ^ 1];
+            } else {
+                res <<= 1;
+                node = node->children[v];
+            }
+        }
+        return res;
+    }
+};
+
+class Solution {
+public:
+    long long maxXor(int n, vector<vector<int>>& edges, vector<int>& values) {
+        vector<vector<int>> g(n);
+        for (auto& e : edges) {
+            int a = e[0], b = e[1];
+            g[a].emplace_back(b);
+            g[b].emplace_back(a);
+        }
+        vector<ll> s(n);
+        function<ll(int, int)> dfs1 = [&](int i, int fa) -> ll {
+            ll t = values[i];
+            for (int j : g[i]) {
+                if (j != fa) t += dfs1(j, i);
+            }
+            s[i] = t;
+            return t;
+        };
+        dfs1(0, -1);
+        Trie tree;
+        ll ans = 0;
+        function<void(int, int)> dfs2 = [&](int i, int fa) {
+            ans = max(ans, tree.search(s[i]));
+            for (int j : g[i]) {
+                if (j != fa) {
+                    dfs2(j, i);
+                }
+            }
+            tree.insert(s[i]);
+        };
+        dfs2(0, -1);
+        return ans;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
-
+type Trie struct {
+	children [2]*Trie
+}
+
+func newTrie() *Trie {
+	return &Trie{}
+}
+
+func (this *Trie) insert(x int) {
+	node := this
+	for i := 47; i >= 0; i-- {
+		v := (x >> i) & 1
+		if node.children[v] == nil {
+			node.children[v] = newTrie()
+		}
+		node = node.children[v]
+	}
+}
+
+func (this *Trie) search(x int) int {
+	node := this
+	res := 0
+	for i := 47; i >= 0; i-- {
+		v := (x >> i) & 1
+		if node == nil {
+			return res
+		}
+		if node.children[v^1] != nil {
+			res = res<<1 | 1
+			node = node.children[v^1]
+		} else {
+			res <<= 1
+			node = node.children[v]
+		}
+	}
+	return res
+}
+
+func maxXor(n int, edges [][]int, values []int) int64 {
+	g := make([][]int, n)
+	for _, e := range edges {
+		a, b := e[0], e[1]
+		g[a] = append(g[a], b)
+		g[b] = append(g[b], a)
+	}
+	s := make([]int, n)
+	var dfs1 func(i, fa int) int
+	dfs1 = func(i, fa int) int {
+		t := values[i]
+		for _, j := range g[i] {
+			if j != fa {
+				t += dfs1(j, i)
+			}
+		}
+		s[i] = t
+		return t
+	}
+	dfs1(0, -1)
+	ans := 0
+	tree := newTrie()
+	var dfs2 func(i, fa int)
+	dfs2 = func(i, fa int) {
+		ans = max(ans, tree.search(s[i]))
+		for _, j := range g[i] {
+			if j != fa {
+				dfs2(j, i)
+			}
+		}
+		tree.insert(s[i])
+	}
+	dfs2(0, -1)
+	return int64(ans)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**