feat: add solutions to lc problem: No.0124

No.0124.Binary Tree Maximum Path Sum

Author: yanglbme

solution/0000-0099/0045.Jump Game II/README.md

@@ -149,9 +149,7 @@ func max(a, b int) int {
 
 ```ts
 function jump(nums: number[]): number {
-    let ans = 0;
-    let mx = 0;
-    let last = 0;
+    let [ans, mx, last] = [0, 0, 0];
     for (let i = 0; i < nums.length - 1; ++i) {
         mx = Math.max(mx, i + nums[i]);
         if (last === i) {

solution/0000-0099/0045.Jump Game II/README_EN.md

@@ -132,9 +132,7 @@ func max(a, b int) int {
 
 ```ts
 function jump(nums: number[]): number {
-    let ans = 0;
-    let mx = 0;
-    let last = 0;
+    let [ans, mx, last] = [0, 0, 0];
     for (let i = 0; i < nums.length - 1; ++i) {
         mx = Math.max(mx, i + nums[i]);
         if (last === i) {

solution/0000-0099/0045.Jump Game II/Solution.ts

@@ -1,7 +1,5 @@
 function jump(nums: number[]): number {
-    let ans = 0;
-    let mx = 0;
-    let last = 0;
+    let [ans, mx, last] = [0, 0, 0];
     for (let i = 0; i < nums.length - 1; ++i) {
         mx = Math.max(mx, i + nums[i]);
         if (last === i) {

solution/0100-0199/0124.Binary Tree Maximum Path Sum/README.md

@@ -42,13 +42,27 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-思考二叉树递归问题的经典套路：
+**方法一：递归**
+
+我们思考二叉树递归问题的经典套路：
 
 1. 终止条件（何时终止递归）
 2. 递归处理左右子树
 3. 合并左右子树的计算结果
 
-对于本题，由于要满足题目对 “路径” 的定义，在返回当前子树对外贡献的最大路径和时，需要取 `left`，`right` 的最大值
+对于本题，我们设计一个函数 $dfs(root)$，它返回以 $root$ 为根节点的二叉树的最大路径和。
+
+函数 $dfs(root)$ 的执行逻辑如下：
+
+如果 $root$ 不存在，那么 $dfs(root)$ 返回 $0$；
+
+否则，我们递归计算 $root$ 的左子树和右子树的最大路径和，分别记为 $left$ 和 $right$。如果 $left$ 小于 $0$，那么我们将其置为 $0$，同理，如果 $right$ 小于 $0$，那么我们将其置为 $0$。
+
+然后，我们用 $root.val + left + right$ 更新答案。最后，函数返回 $root.val + \max(left, right)$。
+
+在主函数中，我们调用 $dfs(root)$，即可得到每个节点的最大路径和，其中的最大值即为答案。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉树的节点数。
 
 <!-- tabs:start -->
 
@@ -64,18 +78,17 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def maxPathSum(self, root: TreeNode) -> int:
-        ans = -inf
-
-        def dfs(node: TreeNode) -> int:
-            if not node:
+    def maxPathSum(self, root: Optional[TreeNode]) -> int:
+        def dfs(root: Optional[TreeNode]) -> int:
+            if root is None:
                 return 0
-            left = max(0, dfs(node.left))
-            right = max(0, dfs(node.right))
+            left = max(0, dfs(root.left))
+            right = max(0, dfs(root.right))
             nonlocal ans
-            ans = max(ans, node.val + left + right)
-            return node.val + max(left, right)
+            ans = max(ans, root.val + left + right)
+            return root.val + max(left, right)
 
+        ans = -inf
         dfs(root)
         return ans
 ```
@@ -101,25 +114,58 @@ class Solution:
  * }
  */
 class Solution {
-    private int ans = Integer.MIN_VALUE;
+    private int ans = -1001;
 
     public int maxPathSum(TreeNode root) {
         dfs(root);
         return ans;
     }
 
-    private int dfs(TreeNode node) {
-        if (node == null) {
+    private int dfs(TreeNode root) {
+        if (root == null) {
             return 0;
         }
-        int left = Math.max(0, dfs(node.left));
-        int right = Math.max(0, dfs(node.right));
-        ans = Math.max(ans, node.val + left + right);
-        return node.val + Math.max(left, right);
+        int left = Math.max(0, dfs(root.left));
+        int right = Math.max(0, dfs(root.right));
+        ans = Math.max(ans, root.val + left + right);
+        return root.val + Math.max(left, right);
     }
 }
 ```
 
+### **C++**
+
+```cpp
+/**
+ * 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 Solution {
+public:
+    int maxPathSum(TreeNode* root) {
+        int ans = -1001;
+        function<int(TreeNode*)> dfs = [&](TreeNode* root) {
+            if (!root) {
+                return 0;
+            }
+            int left = max(0, dfs(root->left));
+            int right = max(0, dfs(root->right));
+            ans = max(ans, left + right + root->val);
+            return root->val + max(left, right);
+        };
+        dfs(root);
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -132,19 +178,17 @@ class Solution {
  * }
  */
 func maxPathSum(root *TreeNode) int {
-	ans := math.MinInt32
-
+	ans := -1001
 	var dfs func(*TreeNode) int
-	dfs = func(node *TreeNode) int {
-		if node == nil {
+	dfs = func(root *TreeNode) int {
+		if root == nil {
 			return 0
 		}
-		left := max(0, dfs(node.Left))
-		right := max(0, dfs(node.Right))
-		ans = max(ans, node.Val+left+right)
-		return node.Val + max(left, right)
+		left := max(0, dfs(root.Left))
+		right := max(0, dfs(root.Right))
+		ans = max(ans, left+right+root.Val)
+		return max(left, right) + root.Val
 	}
-
 	dfs(root)
 	return ans
 }
@@ -157,39 +201,37 @@ func max(a, b int) int {
 }
 ```
 
-### **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:
-    int maxPathSum(TreeNode* root) {
-        int ans = INT_MIN;
 
-        function<int(TreeNode*)> dfs = [&](TreeNode* node) {
-            if (node == nullptr) {
-                return 0;
-            }
-            int left = max(0, dfs(node->left));
-            int right = max(0, dfs(node->right));
-            ans = max(ans, node->val + left + right);
-            return node->val + max(left, right);
-        };
-
-        dfs(root);
-        return ans;
-    }
-};
+function maxPathSum(root: TreeNode | null): number {
+    let ans = -1001;
+    const dfs = (root: TreeNode | null): number => {
+        if (!root) {
+            return 0;
+        }
+        const left = Math.max(0, dfs(root.left));
+        const right = Math.max(0, dfs(root.right));
+        ans = Math.max(ans, left + right + root.val);
+        return Math.max(left, right) + root.val;
+    };
+    dfs(root);
+    return ans;
+}
 ```
 
 ### **JavaScript**
@@ -208,15 +250,15 @@ public:
  * @return {number}
  */
 var maxPathSum = function (root) {
-    let ans = -1000;
-    let dfs = function (root) {
+    let ans = -1001;
+    const dfs = root => {
         if (!root) {
             return 0;
         }
         const left = Math.max(0, dfs(root.left));
         const right = Math.max(0, dfs(root.right));
         ans = Math.max(ans, left + right + root.val);
-        return root.val + Math.max(left, right);
+        return Math.max(left, right) + root.val;
     };
     dfs(root);
     return ans;
@@ -240,17 +282,17 @@ var maxPathSum = function (root) {
  * }
  */
 public class Solution {
-    private int ans;
+    private int ans = -1001;
 
     public int MaxPathSum(TreeNode root) {
-        ans = int.MinValue;
         dfs(root);
         return ans;
     }
 
-    private int dfs(TreeNode root)
-    {
-        if (root == null) return 0;
+    private int dfs(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
         int left = Math.Max(0, dfs(root.left));
         int right = Math.Max(0, dfs(root.right));
         ans = Math.Max(ans, left + right + root.val);