Fix the code of preorder_traversal_iii_compact

codes/cpp/chapter_backtracking/preorder_traversal_iii_compact.cpp

@@ -20,6 +20,7 @@ void preOrder(TreeNode *root) {
     if (root->val == 7) {
         // 记录解
         res.push_back(path);
+        path.pop_back();
         return;
     }
     preOrder(root->left);

codes/csharp/chapter_backtracking/preorder_traversal_iii_compact.cs

@@ -21,6 +21,7 @@ public class preorder_traversal_iii_compact {
         if (root.val == 7) {
             // 记录解
             res.Add(new List<TreeNode>(path));
+            path.RemoveAt(path.Count - 1);
             return;
         }
         preOrder(root.left);
@@ -40,7 +41,7 @@ public class preorder_traversal_iii_compact {
         res = new List<List<TreeNode>>();
         preOrder(root);
 
-        Console.WriteLine("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点");
+        Console.WriteLine("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点");
         foreach (List<TreeNode> path in res) {
             PrintUtil.PrintList(path.Select(p => p.val).ToList());
         }

codes/go/chapter_backtracking/preorder_traversal_iii_compact.go

@@ -19,6 +19,7 @@ func preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {
 	if int(root.Val) == 7 {
 		// 记录解
 		*res = append(*res, *path)
+		*path = (*path)[:len(*path)-1]
 		return
 	}
 	preOrderIII(root.Left, res, path)

codes/go/chapter_backtracking/preorder_traversal_test.go

@@ -59,7 +59,7 @@ func TestPreorderTraversalIIICompact(t *testing.T) {
 	res := make([][]*TreeNode, 0)
 	preOrderIII(root, &res, &path)
 
-	fmt.Println("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点")
+	fmt.Println("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点")
 	for _, path := range res {
 		for _, node := range path {
 			fmt.Printf("%v ", node.Val)
@@ -81,7 +81,7 @@ func TestPreorderTraversalIIITemplate(t *testing.T) {
 	choices = append(choices, root)
 	backtrackIII(&state, &choices, &res)
 
-	fmt.Println("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点")
+	fmt.Println("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点")
 	for _, path := range res {
 		for _, node := range path {
 			fmt.Printf("%v ", node.Val)

codes/java/chapter_backtracking/preorder_traversal_iii_compact.java

@@ -24,6 +24,7 @@ public class preorder_traversal_iii_compact {
         if (root.val == 7) {
             // 记录解
             res.add(new ArrayList<>(path));
+            path.remove(path.size() - 1);
             return;
         }
         preOrder(root.left);
@@ -42,7 +43,7 @@ public class preorder_traversal_iii_compact {
         res = new ArrayList<>();
         preOrder(root);
 
-        System.out.println("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点");
+        System.out.println("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点");
         for (List<TreeNode> path : res) {
             List<Integer> vals = new ArrayList<>();
             for (TreeNode node : path) {

codes/javascript/chapter_backtracking/preorder_traversal_iii_compact.js

@@ -18,6 +18,7 @@ function preOrder(root, path, res) {
     if (root.val === 7) {
         // 记录解
         res.push([...path]);
+        path.pop();
         return;
     }
     preOrder(root.left, path, res);
@@ -36,7 +37,7 @@ const path = [];
 const res = [];
 preOrder(root, path, res);
 
-console.log('\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点');
+console.log('\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点');
 res.forEach((path) => {
     console.log(path.map((node) => node.val));
 });

codes/python/chapter_backtracking/preorder_traversal_iii_compact.py

@@ -20,6 +20,7 @@ def pre_order(root: TreeNode) -> None:
     if root.val == 7:
         # 记录解
         res.append(list(path))
+        path.pop()
         return
     pre_order(root.left)
     pre_order(root.right)
@@ -38,6 +39,6 @@ if __name__ == "__main__":
     res = list[list[TreeNode]]()
     pre_order(root)
 
-    print("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点")
+    print("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点")
     for path in res:
         print([node.val for node in path])

codes/rust/chapter_backtracking/preorder_traversal_iii_compact.rs

@@ -21,6 +21,7 @@ fn pre_order(res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>, path: &mut Vec<Rc<RefCel
         if node.borrow().val == 7 {
             // 记录解
             res.push(path.clone());
+            path.remove(path.len() -  1);
             return;
         }
         pre_order(res, path, node.borrow().left.clone());
@@ -41,7 +42,7 @@ pub fn main() {
     let mut res = Vec::new();
     pre_order(&mut res, &mut path, root);
 
-    println!("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点");
+    println!("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点");
     for path in res {
         let mut vals = Vec::new();
         for node in path {

codes/swift/chapter_backtracking/preorder_traversal_iii_compact.swift

@@ -20,6 +20,7 @@ func preOrder(root: TreeNode?) {
     if root.val == 7 {
         // 记录解
         res.append(path)
+        path.removeLast()
         return
     }
     preOrder(root: root.left)
@@ -41,7 +42,7 @@ enum PreorderTraversalIIICompact {
         res = []
         preOrder(root: root)
 
-        print("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点")
+        print("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点")
         for path in res {
             var vals: [Int] = []
             for node in path {

codes/swift/chapter_backtracking/preorder_traversal_iii_template.swift

@@ -65,7 +65,7 @@ enum PreorderTraversalIIITemplate {
         var res: [[TreeNode]] = []
         backtrack(state: &state, choices: [root].compactMap { $0 }, res: &res)
 
-        print("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点")
+        print("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点")
         for path in res {
             var vals: [Int] = []
             for node in path {

codes/typescript/chapter_backtracking/preorder_traversal_iii_compact.ts

@@ -23,6 +23,7 @@ function preOrder(
     if (root.val === 7) {
         // 记录解
         res.push([...path]);
+        path.pop();
         return;
     }
     preOrder(root.left, path, res);
@@ -41,7 +42,7 @@ const path: TreeNode[] = [];
 const res: TreeNode[][] = [];
 preOrder(root, path, res);
 
-console.log('\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点');
+console.log('\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点');
 res.forEach((path) => {
     console.log(path.map((node) => node.val));
 });