feat: update solutions to lc problem: No.0257 (doocs#1592)

No.0257.Binary Tree Paths

Author: yanglbme

solution/0200-0299/0210.Course Schedule II/README.md

@@ -57,13 +57,16 @@
 
 **方法一：拓扑排序**
 
-对于本题，我们可以将课程看作图中的节点，先修课程看作图中的边，那么我们可以将本题转化为判断有向图中是否存在环。
+我们创建一个邻接表 $g$，用于存储每个节点的后继节点，同时还需要一个数组 $indeg$ 存储每个节点的入度。在构建邻接表的同时，我们也统计每个节点的入度。当入度为 $0$ 的节点代表没有任何前置课程，可以直接学习，我们将其加入队列 $q$ 中。
 
-具体地，我们可以使用拓扑排序的思想，对于每个入度为 $0$ 的节点，我们将其出度的节点的入度减 $1$，直到所有节点都被遍历到。
+当队列 $q$ 不为空的时候，我们取出队首的节点 $i$：
 
-如果所有节点都被遍历到，说明图中不存在环，那么我们就可以完成所有课程的学习；否则，我们就无法完成所有课程的学习。
+-   我们将 $i$ 放入答案中；
+-   接下来，我们将 $i$ 的所有后继节点的入度减少 $1$。如果发现某个后继节点 $j$ 的入度变为 $0$，则将 $j$ 放入队列 $q$ 中。
 
-时间复杂度 $O(n + m)$，空间复杂度 $O(n + m)$。其中 $n$ 和 $m$ 分别为课程数和先修课程数。
+在广度优先搜索的结束时，如果答案中包含了这 $n$ 个节点，那么我们就找到了一种拓扑排序，否则说明图中存在环，也就不存在拓扑排序了。
+
+时间复杂度 $O(n + m)$，空间复杂度 $O(n + m)$。其中 $n$ 和 $m$ 分别是节点数和边数。
 
 <!-- tabs:start -->
 

solution/0200-0299/0257.Binary Tree Paths/README.md

@@ -38,7 +38,11 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-深度优先搜索+路径记录。
+**方法一：DFS**
+
+我们可以使用深度优先搜索的方法遍历整棵二叉树，每一次我们将当前的节点添加到路径中。如果当前的节点是叶子节点，则我们将整个路径加入到答案中。否则我们继续递归遍历节点的孩子节点。最后当我们递归结束返回到当前节点时，我们需要将当前节点从路径中删除。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 是二叉树的节点数。
 
 <!-- tabs:start -->
 
@@ -54,19 +58,20 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def binaryTreePaths(self, root: TreeNode) -> List[str]:
-        def dfs(root):
+    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
+        def dfs(root: Optional[TreeNode]):
             if root is None:
                 return
             t.append(str(root.val))
             if root.left is None and root.right is None:
-                ans.append('->'.join(t))
-            dfs(root.left)
-            dfs(root.right)
+                ans.append("->".join(t))
+            else:
+                dfs(root.left)
+                dfs(root.right)
             t.pop()
 
-        t = []
         ans = []
+        t = []
         dfs(root)
         return ans
 ```
@@ -92,12 +97,10 @@ class Solution:
  * }
  */
 class Solution {
-    private List<String> ans;
-    private List<String> t;
+    private List<String> ans = new ArrayList<>();
+    private List<String> t = new ArrayList<>();
 
     public List<String> binaryTreePaths(TreeNode root) {
-        ans = new ArrayList<>();
-        t = new ArrayList<>();
         dfs(root);
         return ans;
     }
@@ -109,45 +112,62 @@ class Solution {
         t.add(root.val + "");
         if (root.left == null && root.right == null) {
             ans.add(String.join("->", t));
+        } else {
+            dfs(root.left);
+            dfs(root.right);
         }
-        dfs(root.left);
-        dfs(root.right);
         t.remove(t.size() - 1);
     }
 }
 ```
 
-### **TypeScript**
+### **C++**
 
-```ts
+```cpp
 /**
  * Definition for a binary tree node.
- * class TreeNode {
- *     val: number
- *     left: TreeNode | null
- *     right: TreeNode | null
- *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
- *         this.val = (val===undefined ? 0 : val)
- *         this.left = (left===undefined ? null : left)
- *         this.right = (right===undefined ? null : right)
- *     }
- * }
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
  */
+class Solution {
+public:
+    vector<string> binaryTreePaths(TreeNode* root) {
+        vector<string> ans;
+        vector<string> t;
+        function<void(TreeNode*)> dfs = [&](TreeNode* root) {
+            if (!root) {
+                return;
+            }
+            t.push_back(to_string(root->val));
+            if (!root->left && !root->right) {
+                ans.push_back(join(t));
+            } else {
+                dfs(root->left);
+                dfs(root->right);
+            }
+            t.pop_back();
+        };
+        dfs(root);
+        return ans;
+    }
 
-function binaryTreePaths(root: TreeNode | null): string[] {
-    let ans = [];
-    let t = [];
-    function dfs(root) {
-        if (!root) return;
-        t.push(String(root.val));
-        if (!root.left && !root.right) ans.push(t.join('->'));
-        dfs(root.left);
-        dfs(root.right);
-        t.pop();
+    string join(vector<string>& t, string sep = "->") {
+        string ans;
+        for (int i = 0; i < t.size(); ++i) {
+            if (i > 0) {
+                ans += sep;
+            }
+            ans += t[i];
+        }
+        return ans;
     }
-    dfs(root);
-    return ans;
-}
+};
 ```
 
 ### **Go**
@@ -161,61 +181,63 @@ function binaryTreePaths(root: TreeNode | null): string[] {
  *     Right *TreeNode
  * }
  */
-func binaryTreePaths(root *TreeNode) []string {
-	var ans []string
-	var t []string
-	var dfs func(root *TreeNode)
+func binaryTreePaths(root *TreeNode) (ans []string) {
+	t := []string{}
+	var dfs func(*TreeNode)
 	dfs = func(root *TreeNode) {
 		if root == nil {
 			return
 		}
 		t = append(t, strconv.Itoa(root.Val))
 		if root.Left == nil && root.Right == nil {
 			ans = append(ans, strings.Join(t, "->"))
+		} else {
+			dfs(root.Left)
+			dfs(root.Right)
 		}
-		dfs(root.Left)
-		dfs(root.Right)
 		t = t[:len(t)-1]
 	}
 	dfs(root)
-	return ans
+	return
 }
 ```
 
-### **C++**
+### **TypeScript**
 
-```cpp
+```ts
 /**
  * Definition for a binary tree node.
- * struct TreeNode {
- *     int val;
- *     TreeNode *left;
- *     TreeNode *right;
- *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
- *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
- *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
- * };
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
  */
-class Solution {
-public:
-    vector<string> ans;
 
-    vector<string> binaryTreePaths(TreeNode* root) {
-        dfs(root, "");
-        return ans;
-    }
-
-    void dfs(TreeNode* root, string t) {
-        t += to_string(root->val);
-        if (!root->left && !root->right) {
-            ans.push_back(t);
+function binaryTreePaths(root: TreeNode | null): string[] {
+    const ans: string[] = [];
+    const t: number[] = [];
+    const dfs = (root: TreeNode | null) => {
+        if (!root) {
             return;
         }
-        t += "->";
-        if (root->left) dfs(root->left, t);
-        if (root->right) dfs(root->right, t);
-    }
-};
+        t.push(root.val);
+        if (!root.left && !root.right) {
+            ans.push(t.join('->'));
+        } else {
+            dfs(root.left);
+            dfs(root.right);
+        }
+        t.pop();
+    };
+    dfs(root);
+    return ans;
+}
 ```
 
 ### **...**