Merge branch 'DaleStudy:main' into main

Author: hoyeongkwak

binary-tree-maximum-path-sum/HoonDongKang.ts

@@ -0,0 +1,38 @@
+/**
+ * [Problem]: [124 Binary Tree Maximum Path Sum
+ * (https://leetcode.com/problems/binary-tree-maximum-path-sum/description/)
+ */
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+//시간복잡도 O(n)
+//공간복잡도 O(h)
+function maxPathSum(root: TreeNode | null): number {
+    if (!root) return 0;
+    let result = root.val;
+
+    function dfs(node: TreeNode | null) {
+        if (!node) return 0;
+
+        let leftMax = Math.max(dfs(node.left), 0);
+        let rightMax = Math.max(dfs(node.right), 0);
+
+        result = Math.max(node.val + leftMax + rightMax, result);
+
+        return node.val + Math.max(leftMax, rightMax);
+    }
+
+    dfs(root);
+    return result;
+}

binary-tree-maximum-path-sum/Jeehay28.ts

@@ -0,0 +1,30 @@
+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;
+  }
+}
+
+// TC: O(n)
+// SC: O(n)
+function maxPathSum(root: TreeNode | null): number {
+  let maxSum = -Infinity;
+
+  const dfs = (node: TreeNode | null) => {
+    if (!node) return 0;
+
+    const leftMax = Math.max(dfs(node.left), 0);
+    const rightMax = Math.max(dfs(node.right), 0);
+
+    maxSum = Math.max(node.val + leftMax + rightMax, maxSum);
+
+    return node.val + Math.max(leftMax, rightMax);
+  };
+
+  dfs(root);
+  return maxSum;
+}

binary-tree-maximum-path-sum/PDKhan.cpp

@@ -0,0 +1,22 @@
+class Solution {
+    public:
+        int dfs(TreeNode* root, int& result){
+            if(root == nullptr)
+                return 0;
+            
+            int left = max(0, dfs(root->left, result));
+            int right = max(0, dfs(root->right, result));
+            int sum = root->val + left + right;
+    
+            result = max(result, sum);
+    
+            return root->val + max(left, right);
+        }
+    
+        int maxPathSum(TreeNode* root) {
+            int result = INT_MIN;
+    
+            dfs(root, result);
+            return result;
+        }
+    };

binary-tree-maximum-path-sum/Tessa1217.java

@@ -0,0 +1,42 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+
+    // 최대 Path 누적 합
+    int maxPathSumVal = Integer.MIN_VALUE;
+
+    // 시간복잡도: O(n), 공간복잡도: O(h) h as height of tree
+    public int maxPathSum(TreeNode root) {
+        maxPathSumChecker(root);
+        return maxPathSumVal;    
+    }
+
+    // 재귀
+    private int maxPathSumChecker(TreeNode node) {
+
+        if (node == null) {
+            return 0;
+        }
+
+        int leftMax = Math.max(maxPathSumChecker(node.left), 0);
+        int rightMax = Math.max(maxPathSumChecker(node.right), 0);
+
+        maxPathSumVal = Math.max(node.val + leftMax + rightMax, maxPathSumVal);
+
+        return node.val + Math.max(leftMax, rightMax);
+    }
+}
+

binary-tree-maximum-path-sum/ayosecu.py

@@ -0,0 +1,54 @@
+from typing import Optional
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+class Solution:
+    """
+        - Time Complexity: O(n), n = The number of nodes
+        - Space Complexity: O(H), H = The height of Tree
+    """
+    def maxPathSum(self, root: Optional[TreeNode]) -> int:
+        self.max_sum = float("-inf")
+
+        def dfs(node):
+            if not node:
+                return 0
+
+            # Find max sum from the left and right children (more than 0)
+            l_sum = max(dfs(node.left), 0)
+            r_sum = max(dfs(node.right), 0)
+
+            # Calculate current sum and update max_sum
+            current_sum = node.val + l_sum + r_sum
+            self.max_sum = max(self.max_sum, current_sum)
+
+            # Return larger path
+            return node.val + max(l_sum, r_sum)
+
+        dfs(root)
+
+        return self.max_sum
+    
+def do_test():
+    sol = Solution()
+
+    root1 = TreeNode(1)
+    root1.left = TreeNode(2)
+    root1.right = TreeNode(3)
+    e1 = 6
+    r1 = sol.maxPathSum(root1)
+    print(f"TC 1 is Passed!" if r1 == e1 else f"TC 1 is Failed! - Expected: {e1}, Result: {r1}")
+
+    root2 = TreeNode(-10)
+    root2.left = TreeNode(9)
+    root2.right = TreeNode(20)
+    root2.right.left = TreeNode(15)
+    root2.right.right = TreeNode(7)
+    e2 = 42
+    r2 = sol.maxPathSum(root2)
+    print(f"TC 2 is Passed!" if r2 == e2 else f"TC 2 is Failed! - Expected: {e2}, Result: {r2}")
+
+do_test()

binary-tree-maximum-path-sum/byol-han.js

@@ -0,0 +1,37 @@
+/**
+ * https://leetcode.com/problems/binary-tree-maximum-path-sum/
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxPathSum = function (root) {
+  let maxSum = -Infinity; // global max
+
+  function dfs(node) {
+    if (!node) return 0;
+
+    // 왼쪽과 오른쪽 서브트리에서 최대 경로 합을 구한다
+    // 음수면 0으로 치환 (해당 서브트리를 포함하지 않는게 더 이득인 경우)
+    let leftMax = Math.max(0, dfs(node.left));
+    let rightMax = Math.max(0, dfs(node.right));
+
+    // 현재 노드를 루트로 하는 경로에서 최대값을 계산 (left + node + right)
+    let currentMax = leftMax + node.val + rightMax;
+
+    // global 최대값 갱신
+    maxSum = Math.max(maxSum, currentMax);
+
+    // 부모 노드로 return 시: 한쪽 방향으로만 선택 가능
+    return node.val + Math.max(leftMax, rightMax);
+  }
+
+  dfs(root);
+  return maxSum;
+};

binary-tree-maximum-path-sum/crumbs22.cpp

@@ -0,0 +1,27 @@
+class Solution {
+	public:
+		int maxPathSum(TreeNode* root) {
+			int res = INT_MIN;
+	
+			dfs(root, res);
+			return res;
+		}
+	
+		int dfs(TreeNode* root, int& res) {
+			if (!root)
+				return 0;
+	
+			// 좌측 부분트리, 우측 부분트리를 각각 계산할 때 dfs의 '반환값'을 활용
+			// 음수값이 나올 경우는 0으로 대체함
+			int left = max(0, dfs(root->left, res));
+			int right = max(0, dfs(root->right, res));
+	
+			// 최종 반환할 값 업데이트
+			// 좌측 트리, 우측 트리, 루트 노드를 모두 통과하는 경로가 현재까지 최댓값인지 비교해서 갱신
+			res = max(res, root->val + left + right);
+	
+			// 상위 노드로 전달되는 값은 root의 값을 포함하는 경로의 값이다
+			// 따라서 좌측 트리 혹은 우측 트리 중 하나의 경로만을 선택해서 통과할 수 있다
+			return root->val + max(left, right);
+		}
+	};

binary-tree-maximum-path-sum/hsskey.js

@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val);
+ *     this.left = (left===undefined ? null : left);
+ *     this.right = (right===undefined ? null : right);
+ * }
+ */
+
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxPathSum = function(root) {
+    let res = [root.val];
+
+    function dfs(node) {
+        if (!node) return 0;
+
+        let leftMax = dfs(node.left);
+        let rightMax = dfs(node.right);
+
+        leftMax = Math.max(leftMax, 0);
+        rightMax = Math.max(rightMax, 0);
+
+        // 경유지점 포함한 경로 최대값 업데이트
+        res[0] = Math.max(res[0], node.val + leftMax + rightMax);
+
+        // 분기하지 않는 경로에서의 최대값 리턴
+        return node.val + Math.max(leftMax, rightMax);
+    }
+
+    dfs(root);
+    return res[0];
+};
+

binary-tree-maximum-path-sum/minji-go.java

@@ -0,0 +1,26 @@
+/**
+ * <a href="https://leetcode.com/problems/binary-tree-maximum-path-sum/">week11-5. binary-tree-maximum-path-sum</a>
+ * <li>Description: Given the root of a binary tree, return the maximum path sum of any non-empty path</li>
+ * <li>Topics: Dynamic Programming, Tree, Depth-First Search, Binary Tree</li>
+ * <li>Time Complexity: O(N), Runtime 0ms   </li>
+ * <li>Space Complexity: O(H), Memory 44.1MB</li>
+ */
+class Solution {
+    public int maxPathSum(TreeNode root) {
+        dfs(root);
+        return max;
+    }
+
+    int max = Integer.MIN_VALUE;
+    public int dfs(TreeNode head) {
+        if (head == null) return 0;
+
+        int left = Math.max(0, dfs(head.left));
+        int right = Math.max(0, dfs(head.right));
+
+        max = Math.max(max, head.val + left + right);
+
+        return head.val + Math.max(left, right);
+    }
+
+}

binary-tree-maximum-path-sum/moonjonghoo.js

@@ -0,0 +1,17 @@
+var maxPathSum = function (root) {
+  let maxSum = -Infinity;
+
+  function dfs(node) {
+    if (node === null) return 0; // 6) Base Case
+    const left = Math.max(dfs(node.left), 0); // 8) Pruning
+    const right = Math.max(dfs(node.right), 0); // 8) Pruning
+
+    const currentSum = left + node.val + right; // 9) Pivot Sum
+    maxSum = Math.max(maxSum, currentSum); // 7) Global Max
+
+    return node.val + Math.max(left, right); // 10) Return Value
+  }
+
+  dfs(root); // 4) DFS 시작
+  console.log(maxSum); // 최종 답 출력
+};