feat: add solutions to lc problem: No.0101

No.0101.Symmetric Tree

Author: yanglbme

solution/0100-0199/0100.Same Tree/README.md

@@ -48,8 +48,20 @@
 
 **方法一：DFS**
 
+我们可以使用 DFS 递归的方法来解决这个问题。
+
+首先判断两个二叉树的根节点是否相同，如果两个根节点都为空，则两个二叉树相同，如果两个根节点中有且只有一个为空，则两个二叉树一定不同。如果两个根节点都不为空，则判断它们的值是否相同，如果不相同则两个二叉树一定不同，如果相同，则分别判断两个二叉树的左子树是否相同以及右子树是否相同。当以上所有条件都满足时，两个二叉树才相同。
+
+时间复杂度 $O(\min(m, n))$，空间复杂度 $O(\min(m, n))$。其中 $m$ 和 $n$ 分别是两个二叉树的节点个数。空间复杂度主要取决于递归调用的层数，递归调用的层数不会超过较小的二叉树的节点个数。
+
 **方法二：BFS**
 
+我们也可以使用 BFS 迭代的方法来解决这个问题。
+
+首先将两个二叉树的根节点分别加入两个队列。每次从两个队列各取出一个节点，进行如下比较操作。如果两个节点的值不相同，则两个二叉树的结构一定不同，如果两个节点的值相同，则判断两个节点的子节点是否为空，如果只有一个节点的左子节点为空，则两个二叉树的结构一定不同，如果只有一个节点的右子节点为空，则两个二叉树的结构一定不同，如果左右子节点的结构相同，则将两个节点的左子节点和右子节点分别加入两个队列，对于下一次迭代，将从两个队列各取出一个节点进行比较。当两个队列同时为空时，说明我们已经比较完了所有节点，两个二叉树的结构完全相同。
+
+时间复杂度 $O(\min(m, n))$，空间复杂度 $O(\min(m, n))$。其中 $m$ 和 $n$ 分别是两个二叉树的节点个数。空间复杂度主要取决于队列中的元素个数，队列中的元素个数不会超过较小的二叉树的节点个数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -66,7 +78,7 @@ DFS：
 #         self.left = left
 #         self.right = right
 class Solution:
-    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
+    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
         if p == q:
             return True
         if p is None or q is None or p.val != q.val:

solution/0100-0199/0100.Same Tree/README_EN.md

@@ -54,7 +54,7 @@ DFS or BFS.
 #         self.left = left
 #         self.right = right
 class Solution:
-    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
+    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
         if p == q:
             return True
         if p is None or q is None or p.val != q.val:

solution/0100-0199/0100.Same Tree/Solution.py

@@ -5,7 +5,7 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
+    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
         if p == q:
             return True
         if p is None or q is None or p.val != q.val:

solution/0100-0199/0101.Symmetric Tree/README.md

@@ -41,6 +41,18 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：递归**
+
+我们设计一个函数 $dfs(root1, root2)$，用于判断两个二叉树是否对称。答案即为 $dfs(root, root)$。
+
+函数 $dfs(root1, root2)$ 的逻辑如下：
+
+-   如果 $root1$ 和 $root2$ 都为空，则两个二叉树对称，返回 `true`；
+-   如果 $root1$ 和 $root2$ 中只有一个为空，或者 $root1.val \neq root2.val$，则两个二叉树不对称，返回 `false`；
+-   否则，判断 $root1$ 的左子树和 $root2$ 的右子树是否对称，以及 $root1$ 的右子树和 $root2$ 的左子树是否对称，这里使用了递归。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉树的节点数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -55,7 +67,7 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def isSymmetric(self, root: TreeNode) -> bool:
+    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
         def dfs(root1, root2):
             if root1 is None and root2 is None:
                 return True
@@ -120,17 +132,42 @@ class Solution {
 class Solution {
 public:
     bool isSymmetric(TreeNode* root) {
+        function<bool(TreeNode*, TreeNode*)> dfs = [&](TreeNode* root1, TreeNode* root2) -> bool {
+            if (!root1 && !root2) return true;
+            if (!root1 || !root2 || root1->val != root2->val) return false;
+            return dfs(root1->left, root2->right) && dfs(root1->right, root2->left);
+        };
         return dfs(root, root);
     }
-
-    bool dfs(TreeNode* root1, TreeNode* root2) {
-        if (!root1 && !root2) return 1;
-        if (!root1 || !root2 || root1->val != root2->val) return 0;
-        return dfs(root1->left, root2->right) && dfs(root1->right, root2->left);
-    }
 };
 ```
 
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func isSymmetric(root *TreeNode) bool {
+	var dfs func(*TreeNode, *TreeNode) bool
+	dfs = func(root1, root2 *TreeNode) bool {
+		if root1 == nil && root2 == nil {
+			return true
+		}
+		if root1 == nil || root2 == nil || root1.Val != root2.Val {
+			return false
+		}
+		return dfs(root1.Left, root2.Right) && dfs(root1.Right, root2.Left)
+	}
+	return dfs(root, root)
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/0100-0199/0101.Symmetric Tree/README_EN.md

@@ -46,7 +46,7 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def isSymmetric(self, root: TreeNode) -> bool:
+    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
         def dfs(root1, root2):
             if root1 is None and root2 is None:
                 return True
@@ -109,17 +109,42 @@ class Solution {
 class Solution {
 public:
     bool isSymmetric(TreeNode* root) {
+        function<bool(TreeNode*, TreeNode*)> dfs = [&](TreeNode* root1, TreeNode* root2) -> bool {
+            if (!root1 && !root2) return true;
+            if (!root1 || !root2 || root1->val != root2->val) return false;
+            return dfs(root1->left, root2->right) && dfs(root1->right, root2->left);
+        };
         return dfs(root, root);
     }
-
-    bool dfs(TreeNode* root1, TreeNode* root2) {
-        if (!root1 && !root2) return 1;
-        if (!root1 || !root2 || root1->val != root2->val) return 0;
-        return dfs(root1->left, root2->right) && dfs(root1->right, root2->left);
-    }
 };
 ```
 
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func isSymmetric(root *TreeNode) bool {
+	var dfs func(*TreeNode, *TreeNode) bool
+	dfs = func(root1, root2 *TreeNode) bool {
+		if root1 == nil && root2 == nil {
+			return true
+		}
+		if root1 == nil || root2 == nil || root1.Val != root2.Val {
+			return false
+		}
+		return dfs(root1.Left, root2.Right) && dfs(root1.Right, root2.Left)
+	}
+	return dfs(root, root)
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/0100-0199/0101.Symmetric Tree/Solution.cpp

@@ -12,12 +12,11 @@
 class Solution {
 public:
     bool isSymmetric(TreeNode* root) {
+        function<bool(TreeNode*, TreeNode*)> dfs = [&](TreeNode* root1, TreeNode* root2) -> bool {
+            if (!root1 && !root2) return true;
+            if (!root1 || !root2 || root1->val != root2->val) return false;
+            return dfs(root1->left, root2->right) && dfs(root1->right, root2->left);
+        };
         return dfs(root, root);
     }
-
-    bool dfs(TreeNode* root1, TreeNode* root2) {
-        if (!root1 && !root2) return 1;
-        if (!root1 || !root2 || root1->val != root2->val) return 0;
-        return dfs(root1->left, root2->right) && dfs(root1->right, root2->left);
-    }
 };

solution/0100-0199/0101.Symmetric Tree/Solution.go

@@ -0,0 +1,21 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func isSymmetric(root *TreeNode) bool {
+	var dfs func(*TreeNode, *TreeNode) bool
+	dfs = func(root1, root2 *TreeNode) bool {
+		if root1 == nil && root2 == nil {
+			return true
+		}
+		if root1 == nil || root2 == nil || root1.Val != root2.Val {
+			return false
+		}
+		return dfs(root1.Left, root2.Right) && dfs(root1.Right, root2.Left)
+	}
+	return dfs(root, root)
+}

solution/0100-0199/0101.Symmetric Tree/Solution.py

@@ -5,7 +5,7 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def isSymmetric(self, root: TreeNode) -> bool:
+    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
         def dfs(root1, root2):
             if root1 is None and root2 is None:
                 return True

solution/2000-2099/2071.Maximum Number of Tasks You Can Assign/Solution.py

@@ -1,5 +1,7 @@
 class Solution:
-    def maxTaskAssign(self, tasks: List[int], workers: List[int], pills: int, strength: int) -> int:
+    def maxTaskAssign(
+        self, tasks: List[int], workers: List[int], pills: int, strength: int
+    ) -> int:
         def check(x):
             i = 0
             q = deque()