feat: add solutions to lc problem: No.2641 (doocs#2297)

yanglbme · web-flow · commit 53fea67f5e71 · 2024-02-02T15:32:35.000+08:00
No.2641.Cousins in Binary Tree II
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/README.md b/solution/2600-2699/2641.Cousins in Binary Tree II/README.md
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/README_EN.md b/solution/2600-2699/2641.Cousins in Binary Tree II/README_EN.md
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/Solution.cpp b/solution/2600-2699/2641.Cousins in Binary Tree II/Solution.cpp
@@ -12,36 +12,36 @@
 class Solution {
 public:
     TreeNode* replaceValueInTree(TreeNode* root) {
-        vector<int> s;
-        function<void(TreeNode*, int)> dfs1 = [&](TreeNode* root, int d) {
-            if (!root) {
-                return;
-            }
-            if (s.size() <= d) {
-                s.push_back(0);
-            }
-            s[d] += root->val;
-            dfs1(root->left, d + 1);
-            dfs1(root->right, d + 1);
-        };
-        function<void(TreeNode*, int)> dfs2 = [&](TreeNode* root, int d) {
-            if (!root) {
-                return;
-            }
-            int l = root->left ? root->left->val : 0;
-            int r = root->right ? root->right->val : 0;
-            if (root->left) {
-                root->left->val = s[d] - l - r;
-            }
-            if (root->right) {
-                root->right->val = s[d] - l - r;
-            }
-            dfs2(root->left, d + 1);
-            dfs2(root->right, d + 1);
-        };
+        memset(s, 0, sizeof(s));
         dfs1(root, 0);
         root->val = 0;
-        dfs2(root, 1);
+        dfs2(root, 0);
         return root;
     }
+
+private:
+    int s[100010];
+    void dfs1(TreeNode* root, int depth) {
+        if (!root) {
+            return;
+        }
+        s[depth] += root->val;
+        dfs1(root->left, depth + 1);
+        dfs1(root->right, depth + 1);
+    };
+
+    void dfs2(TreeNode* root, int depth) {
+        int l = root->left ? root->left->val : 0;
+        int r = root->right ? root->right->val : 0;
+        int sub = l + r;
+        ++depth;
+        if (root->left) {
+            root->left->val = s[depth] - sub;
+            dfs2(root->left, depth);
+        }
+        if (root->right) {
+            root->right->val = s[depth] - sub;
+            dfs2(root->right, depth);
+        }
+    };
 };
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/Solution.go b/solution/2600-2699/2641.Cousins in Binary Tree II/Solution.go
@@ -9,40 +9,39 @@
 func replaceValueInTree(root *TreeNode) *TreeNode {
 	s := []int{}
 	var dfs1 func(*TreeNode, int)
-	dfs1 = func(root *TreeNode, d int) {
+	dfs1 = func(root *TreeNode, depth int) {
 		if root == nil {
 			return
 		}
-		if len(s) <= d {
+		if len(s) <= depth {
 			s = append(s, 0)
 		}
-		s[d] += root.Val
-		dfs1(root.Left, d+1)
-		dfs1(root.Right, d+1)
+		s[depth] += root.Val
+		dfs1(root.Left, depth+1)
+		dfs1(root.Right, depth+1)
 	}
 	var dfs2 func(*TreeNode, int)
-	dfs2 = func(root *TreeNode, d int) {
-		if root == nil {
-			return
-		}
+	dfs2 = func(root *TreeNode, depth int) {
 		l, r := 0, 0
 		if root.Left != nil {
 			l = root.Left.Val
 		}
 		if root.Right != nil {
 			r = root.Right.Val
 		}
+		sub := l + r
+		depth++
 		if root.Left != nil {
-			root.Left.Val = s[d] - l - r
+			root.Left.Val = s[depth] - sub
+			dfs2(root.Left, depth)
 		}
 		if root.Right != nil {
-			root.Right.Val = s[d] - l - r
+			root.Right.Val = s[depth] - sub
+			dfs2(root.Right, depth)
 		}
-		dfs2(root.Left, d+1)
-		dfs2(root.Right, d+1)
 	}
 	dfs1(root, 0)
 	root.Val = 0
-	dfs2(root, 1)
+	dfs2(root, 0)
 	return root
 }
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/Solution.java b/solution/2600-2699/2641.Cousins in Binary Tree II/Solution.java
@@ -19,35 +19,34 @@ class Solution {
     public TreeNode replaceValueInTree(TreeNode root) {
         dfs1(root, 0);
         root.val = 0;
-        dfs2(root, 1);
+        dfs2(root, 0);
         return root;
     }
 
-    private void dfs1(TreeNode root, int d) {
+    private void dfs1(TreeNode root, int depth) {
         if (root == null) {
             return;
         }
-        if (s.size() <= d) {
+        if (s.size() <= depth) {
             s.add(0);
         }
-        s.set(d, s.get(d) + root.val);
-        dfs1(root.left, d + 1);
-        dfs1(root.right, d + 1);
+        s.set(depth, s.get(depth) + root.val);
+        dfs1(root.left, depth + 1);
+        dfs1(root.right, depth + 1);
     }
 
-    private void dfs2(TreeNode root, int d) {
-        if (root == null) {
-            return;
-        }
+    private void dfs2(TreeNode root, int depth) {
         int l = root.left == null ? 0 : root.left.val;
         int r = root.right == null ? 0 : root.right.val;
+        int sub = l + r;
+        ++depth;
         if (root.left != null) {
-            root.left.val = s.get(d) - l - r;
+            root.left.val = s.get(depth) - sub;
+            dfs2(root.left, depth);
         }
         if (root.right != null) {
-            root.right.val = s.get(d) - l - r;
+            root.right.val = s.get(depth) - sub;
+            dfs2(root.right, depth);
         }
-        dfs2(root.left, d + 1);
-        dfs2(root.right, d + 1);
     }
 }
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/Solution.py b/solution/2600-2699/2641.Cousins in Binary Tree II/Solution.py
@@ -6,30 +6,29 @@
 #         self.right = right
 class Solution:
     def replaceValueInTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
-        def dfs1(root, d):
+        def dfs1(root: Optional[TreeNode], depth: int):
             if root is None:
                 return
-            if len(s) <= d:
+            if len(s) <= depth:
                 s.append(0)
-            s[d] += root.val
-            dfs1(root.left, d + 1)
-            dfs1(root.right, d + 1)
+            s[depth] += root.val
+            dfs1(root.left, depth + 1)
+            dfs1(root.right, depth + 1)
 
-        def dfs2(root, d):
-            if root is None:
-                return
-            t = (root.left.val if root.left else 0) + (
+        def dfs2(root: Optional[TreeNode], depth: int):
+            sub = (root.left.val if root.left else 0) + (
                 root.right.val if root.right else 0
             )
+            depth += 1
             if root.left:
-                root.left.val = s[d] - t
+                root.left.val = s[depth] - sub
+                dfs2(root.left, depth)
             if root.right:
-                root.right.val = s[d] - t
-            dfs2(root.left, d + 1)
-            dfs2(root.right, d + 1)
+                root.right.val = s[depth] - sub
+                dfs2(root.right, depth)
 
         s = []
         dfs1(root, 0)
         root.val = 0
-        dfs2(root, 1)
+        dfs2(root, 0)
         return root
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/Solution.ts b/solution/2600-2699/2641.Cousins in Binary Tree II/Solution.ts
@@ -14,33 +14,31 @@
 
 function replaceValueInTree(root: TreeNode | null): TreeNode | null {
     const s: number[] = [];
-    const dfs1 = (root: TreeNode | null, d: number): void => {
+    const dfs1 = (root: TreeNode | null, depth: number) => {
         if (!root) {
             return;
         }
-        if (s.length <= d) {
+        if (s.length <= depth) {
             s.push(0);
         }
-        s[d] += root.val;
-        dfs1(root.left, d + 1);
-        dfs1(root.right, d + 1);
+        s[depth] += root.val;
+        dfs1(root.left, depth + 1);
+        dfs1(root.right, depth + 1);
     };
-    const dfs2 = (root: TreeNode | null, d: number): void => {
-        if (!root) {
-            return;
-        }
-        const t = (root.left?.val ?? 0) + (root.right?.val ?? 0);
+    const dfs2 = (root: TreeNode | null, depth: number) => {
+        const sub = (root.left?.val || 0) + (root.right?.val || 0);
+        ++depth;
         if (root.left) {
-            root.left.val = s[d] - t;
+            root.left.val = s[depth] - sub;
+            dfs2(root.left, depth);
         }
         if (root.right) {
-            root.right.val = s[d] - t;
+            root.right.val = s[depth] - sub;
+            dfs2(root.right, depth);
         }
-        dfs2(root.left, d + 1);
-        dfs2(root.right, d + 1);
     };
     dfs1(root, 0);
     root.val = 0;
-    dfs2(root, 1);
+    dfs2(root, 0);
     return root;
 }
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/Solution2.cpp b/solution/2600-2699/2641.Cousins in Binary Tree II/Solution2.cpp
@@ -13,31 +13,30 @@ class Solution {
 public:
     TreeNode* replaceValueInTree(TreeNode* root) {
         root->val = 0;
-        vector<TreeNode*> q;
-        q.emplace_back(root);
+        vector<TreeNode*> q = {root};
         while (!q.empty()) {
-            vector<TreeNode*> p = q;
-            q.clear();
+            vector<TreeNode*> t;
             int s = 0;
-            for (TreeNode* node : p) {
+            for (TreeNode* node : q) {
                 if (node->left) {
-                    q.emplace_back(node->left);
+                    t.emplace_back(node->left);
                     s += node->left->val;
                 }
                 if (node->right) {
-                    q.emplace_back(node->right);
+                    t.emplace_back(node->right);
                     s += node->right->val;
                 }
             }
-            for (TreeNode* node : p) {
-                int t = (node->left ? node->left->val : 0) + (node->right ? node->right->val : 0);
+            for (TreeNode* node : q) {
+                int sub = (node->left ? node->left->val : 0) + (node->right ? node->right->val : 0);
                 if (node->left) {
-                    node->left->val = s - t;
+                    node->left->val = s - sub;
                 }
                 if (node->right) {
-                    node->right->val = s - t;
+                    node->right->val = s - sub;
                 }
             }
+            q = move(t);
         }
         return root;
     }
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/Solution2.go b/solution/2600-2699/2641.Cousins in Binary Tree II/Solution2.go
@@ -10,34 +10,34 @@ func replaceValueInTree(root *TreeNode) *TreeNode {
 	root.Val = 0
 	q := []*TreeNode{root}
 	for len(q) > 0 {
-		p := q
-		q = []*TreeNode{}
+		t := []*TreeNode{}
 		s := 0
-		for _, node := range p {
+		for _, node := range q {
 			if node.Left != nil {
-				q = append(q, node.Left)
+				t = append(t, node.Left)
 				s += node.Left.Val
 			}
 			if node.Right != nil {
-				q = append(q, node.Right)
+				t = append(t, node.Right)
 				s += node.Right.Val
 			}
 		}
-		for _, node := range p {
-			t := 0
+		for _, node := range q {
+			sub := 0
 			if node.Left != nil {
-				t += node.Left.Val
+				sub += node.Left.Val
 			}
 			if node.Right != nil {
-				t += node.Right.Val
+				sub += node.Right.Val
 			}
 			if node.Left != nil {
-				node.Left.Val = s - t
+				node.Left.Val = s - sub
 			}
 			if node.Right != nil {
-				node.Right.Val = s - t
+				node.Right.Val = s - sub
 			}
 		}
+		q = t
 	}
 	return root
 }
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/Solution2.java b/solution/2600-2699/2641.Cousins in Binary Tree II/Solution2.java
@@ -18,29 +18,29 @@ public TreeNode replaceValueInTree(TreeNode root) {
         root.val = 0;
         List<TreeNode> q = List.of(root);
         while (!q.isEmpty()) {
-            List<TreeNode> p = q;
-            q = new ArrayList<>();
+            List<TreeNode> t = new ArrayList<>();
             int s = 0;
-            for (TreeNode node : p) {
+            for (TreeNode node : q) {
                 if (node.left != null) {
-                    q.add(node.left);
+                    t.add(node.left);
                     s += node.left.val;
                 }
                 if (node.right != null) {
-                    q.add(node.right);
+                    t.add(node.right);
                     s += node.right.val;
                 }
             }
-            for (TreeNode node : p) {
-                int t = (node.left == null ? 0 : node.left.val)
+            for (TreeNode node : q) {
+                int sub = (node.left == null ? 0 : node.left.val)
                     + (node.right == null ? 0 : node.right.val);
                 if (node.left != null) {
-                    node.left.val = s - t;
+                    node.left.val = s - sub;
                 }
                 if (node.right != null) {
-                    node.right.val = s - t;
+                    node.right.val = s - sub;
                 }
             }
+            q = t;
         }
         return root;
     }
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/Solution2.py b/solution/2600-2699/2641.Cousins in Binary Tree II/Solution2.py
diff --git a/solution/2600-2699/2641.Cousins in Binary Tree II/Solution2.ts b/solution/2600-2699/2641.Cousins in Binary Tree II/Solution2.ts

Original file line number	Diff line number	Diff line change
`@@ -13,31 +13,30 @@ class Solution {`
`13`	`13`	`public:`
`14`	`14`	`TreeNode* replaceValueInTree(TreeNode* root) {`
`15`	`15`	`root->val = 0;`
`16`		`- vector<TreeNode*> q;`
`17`		`- q.emplace_back(root);`
	`16`	`+ vector<TreeNode*> q = {root};`
`18`	`17`	`while (!q.empty()) {`
`19`		`- vector<TreeNode*> p = q;`
`20`		`- q.clear();`
	`18`	`+ vector<TreeNode*> t;`
`21`	`19`	`int s = 0;`
`22`		`- for (TreeNode* node : p) {`
	`20`	`+ for (TreeNode* node : q) {`
`23`	`21`	`if (node->left) {`
`24`		`- q.emplace_back(node->left);`
	`22`	`+ t.emplace_back(node->left);`
`25`	`23`	`s += node->left->val;`
`26`	`24`	`}`
`27`	`25`	`if (node->right) {`
`28`		`- q.emplace_back(node->right);`
	`26`	`+ t.emplace_back(node->right);`
`29`	`27`	`s += node->right->val;`
`30`	`28`	`}`
`31`	`29`	`}`
`32`		`- for (TreeNode* node : p) {`
`33`		`- int t = (node->left ? node->left->val : 0) + (node->right ? node->right->val : 0);`
	`30`	`+ for (TreeNode* node : q) {`
	`31`	`+ int sub = (node->left ? node->left->val : 0) + (node->right ? node->right->val : 0);`
`34`	`32`	`if (node->left) {`
`35`		`- node->left->val = s - t;`
	`33`	`+ node->left->val = s - sub;`
`36`	`34`	`}`
`37`	`35`	`if (node->right) {`
`38`		`- node->right->val = s - t;`
	`36`	`+ node->right->val = s - sub;`
`39`	`37`	`}`
`40`	`38`	`}`
	`39`	`+ q = move(t);`
`41`	`40`	`}`
`42`	`41`	`return root;`
`43`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,34 +10,34 @@ func replaceValueInTree(root TreeNode) TreeNode {`
`10`	`10`	`root.Val = 0`
`11`	`11`	`q := []*TreeNode{root}`
`12`	`12`	`for len(q) > 0 {`
`13`		`- p := q`
`14`		`- q = []*TreeNode{}`
	`13`	`+ t := []*TreeNode{}`
`15`	`14`	`s := 0`
`16`		`- for _, node := range p {`
	`15`	`+ for _, node := range q {`
`17`	`16`	`if node.Left != nil {`
`18`		`- q = append(q, node.Left)`
	`17`	`+ t = append(t, node.Left)`
`19`	`18`	`s += node.Left.Val`
`20`	`19`	`}`
`21`	`20`	`if node.Right != nil {`
`22`		`- q = append(q, node.Right)`
	`21`	`+ t = append(t, node.Right)`
`23`	`22`	`s += node.Right.Val`
`24`	`23`	`}`
`25`	`24`	`}`
`26`		`- for _, node := range p {`
`27`		`- t := 0`
	`25`	`+ for _, node := range q {`
	`26`	`+ sub := 0`
`28`	`27`	`if node.Left != nil {`
`29`		`- t += node.Left.Val`
	`28`	`+ sub += node.Left.Val`
`30`	`29`	`}`
`31`	`30`	`if node.Right != nil {`
`32`		`- t += node.Right.Val`
	`31`	`+ sub += node.Right.Val`
`33`	`32`	`}`
`34`	`33`	`if node.Left != nil {`
`35`		`- node.Left.Val = s - t`
	`34`	`+ node.Left.Val = s - sub`
`36`	`35`	`}`
`37`	`36`	`if node.Right != nil {`
`38`		`- node.Right.Val = s - t`
	`37`	`+ node.Right.Val = s - sub`
`39`	`38`	`}`
`40`	`39`	`}`
	`40`	`+ q = t`
`41`	`41`	`}`
`42`	`42`	`return root`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,29 +18,29 @@ public TreeNode replaceValueInTree(TreeNode root) {`
`18`	`18`	`root.val = 0;`
`19`	`19`	`List<TreeNode> q = List.of(root);`
`20`	`20`	`while (!q.isEmpty()) {`
`21`		`- List<TreeNode> p = q;`
`22`		`- q = new ArrayList<>();`
	`21`	`+ List<TreeNode> t = new ArrayList<>();`
`23`	`22`	`int s = 0;`
`24`		`- for (TreeNode node : p) {`
	`23`	`+ for (TreeNode node : q) {`
`25`	`24`	`if (node.left != null) {`
`26`		`- q.add(node.left);`
	`25`	`+ t.add(node.left);`
`27`	`26`	`s += node.left.val;`
`28`	`27`	`}`
`29`	`28`	`if (node.right != null) {`
`30`		`- q.add(node.right);`
	`29`	`+ t.add(node.right);`
`31`	`30`	`s += node.right.val;`
`32`	`31`	`}`
`33`	`32`	`}`
`34`		`- for (TreeNode node : p) {`
`35`		`- int t = (node.left == null ? 0 : node.left.val)`
	`33`	`+ for (TreeNode node : q) {`
	`34`	`+ int sub = (node.left == null ? 0 : node.left.val)`
`36`	`35`	`+ (node.right == null ? 0 : node.right.val);`
`37`	`36`	`if (node.left != null) {`
`38`		`- node.left.val = s - t;`
	`37`	`+ node.left.val = s - sub;`
`39`	`38`	`}`
`40`	`39`	`if (node.right != null) {`
`41`		`- node.right.val = s - t;`
	`40`	`+ node.right.val = s - sub;`
`42`	`41`	`}`
`43`	`42`	`}`
	`43`	`+ q = t;`
`44`	`44`	`}`
`45`	`45`	`return root;`
`46`	`46`	`}`