Merge branch 'DaleStudy:main' into main

Author: lhc0506

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/hoyeongkwak.ts

@@ -0,0 +1,33 @@
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+/*
+Time complexity: O(N)
+Space complexity: O(N) h: 트리의 높이
+*/
+function maxPathSum(root: TreeNode | null): number {
+    let maxSum = -Infinity
+    const dfs = (node: TreeNode): number => {
+        if (node == null) return 0
+
+        const leftMax = Math.max(0, dfs(node.left))
+        const rightMax = Math.max(0, dfs(node.right))
+        const currentMax = node.val + leftMax + rightMax
+
+        maxSum = Math.max(maxSum, currentMax)
+        return node.val + Math.max(leftMax, rightMax)
+    }
+    dfs(root)
+    return maxSum
+};

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/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); // 최종 답 출력
+};

binary-tree-maximum-path-sum/printjin-gmailcom.py

@@ -0,0 +1,12 @@
+class Solution:
+    def maxPathSum(self, root):
+        self.max_sum = float('-inf')
+        def dfs(node):
+            if not node:
+                return 0
+            left = max(dfs(node.left), 0)
+            right = max(dfs(node.right), 0)
+            self.max_sum = max(self.max_sum, node.val + left + right)
+            return node.val + max(left, right)
+        dfs(root)
+        return self.max_sum

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

@@ -0,0 +1,61 @@
+# https://leetcode.com/problems/binary-tree-maximum-path-sum/
+
+from typing import Optional
+
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def maxPathSum(self, root: Optional[TreeNode]) -> int:
+        """
+        [Complexity]
+            - TC: O(n) (각 node를 한 번씩 방문)
+            - SC: O(height) (tree의 높이만큼 call stack)
+
+        [Approach]
+            path에는 같은 node가 두 번 들어갈 수 없으므로, 각 node 마다 해당 node를 지난 path의 max sum은 다음과 같이 구할 수 있다.
+                = (1) left child를 지나는 path의 max_sum
+                  + (2) right child를 지나는 path의 max_sum
+                  + (3) 현재 node의 val
+            따라서 이는 재귀 문제로 풀 수 있으며, 각 단계마다 global max sum과 비교하며 값을 업데이트 하면 된다.
+
+            이때 node의 값은 음수가 될 수 있으므로, (1) & (2)가 음수라면 0으로 처리해야 한다. 즉,
+                = (1) max(get_max_sum(node.left), 0)
+                  + (2) max(get_max_sum(node.right), 0)
+                  + (3) 현재 node의 val
+            과 같이 구하고, global max sum과 이 값을 비교하면 된다.
+
+            또한, 현재 보고 있는 node가 get_max_sum() 함수의 반환값은
+                = 현재 node의 값 + (1) & (2) 중 큰 값
+            이어야 한다. 왜냐하면 현재 node를 두 번 이상 방문할 수 없기 때문이다.
+        """
+
+        res = -1001
+
+        def get_max_sum(node):
+            """주어진 node가 root인 tree에서, root를 지나는 path의 max sum을 구하는 함수"""
+            nonlocal res
+
+            # base condition
+            if not node:
+                return 0
+
+            # compute left & right child's max path sum
+            left_max_sum = max(get_max_sum(node.left), 0)
+            right_max_sum = max(get_max_sum(node.right), 0)
+
+            # compute max path sum at this step
+            max_sum = left_max_sum + right_max_sum + node.val
+
+            # update res
+            res = max(res, max_sum)
+
+            return node.val + max(left_max_sum, right_max_sum)
+
+        get_max_sum(root)
+
+        return res

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

@@ -0,0 +1,15 @@
+"""
+[문제풀이]
+# Inputs
+
+# Outputs
+
+# Constraints
+
+# Ideas
+
+[회고]
+
+"""
+
+