chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-01-07-1339-Maximum-Product-of-Splitted-Binary-Tree/explanation.md

@@ -0,0 +1,37 @@
+# Maximum Product of Splitted Binary Tree (Medium)
+
+**Problem ID:** 1339  
+**Date:** 2026-01-07  
+**Link:** https://leetcode.com/problems/maximum-product-of-splitted-binary-tree/
+
+## Approach
+
+To solve the problem of maximizing the product of the sums of two subtrees obtained by splitting a binary tree, we can follow a systematic approach:
+
+### Problem Breakdown
+1. **Understanding the Tree Structure**: We need to consider how splitting the tree at various edges affects the sums of the resulting subtrees. Each edge can be thought of as a potential split point.
+
+2. **Sum Calculation**: The first step is to calculate the total sum of all node values in the tree. This will help us determine the sum of one subtree once we know the sum of the other subtree (since the total sum is constant).
+
+3. **DFS for Subtree Sums**: We can perform a Depth-First Search (DFS) traversal to calculate the sum of each subtree rooted at every node. During this traversal:
+   - For each node, compute the sum of its subtree.
+   - Store the subtree sums in a list or variable.
+
+4. **Maximizing the Product**: As we compute the subtree sums, we can calculate the product of the sum of the current subtree with the sum of the remaining tree (which is the total sum minus the current subtree sum). Specifically, for a subtree sum `subtree_sum`, the product can be calculated as:
+   \[
+   \text{product} = \text{subtree\_sum} \times (\text{total\_sum} - \text{subtree\_sum})
+   \]
+   We need to keep track of the maximum product encountered during this process.
+
+5. **Modulo Operation**: Since the result can be very large, we will take the product modulo \(10^9 + 7\) at the end.
+
+### Data Structures
+- A binary tree structure to represent the nodes.
+- Variables to store the total sum of the tree and the maximum product found.
+
+### Complexity
+- **Time Complexity**: The algorithm primarily consists of a single DFS traversal of the tree, which takes \(O(N)\) time, where \(N\) is the number of nodes in the tree.
+- **Space Complexity**: The space complexity is \(O(H)\) for the recursion stack, where \(H\) is the height of the tree. In the worst case (for a skewed tree), this could be \(O(N)\), but for a balanced tree, it would be \(O(\log N)\).
+
+### Summary
+By leveraging a DFS to calculate subtree sums and simultaneously compute the maximum product of the sums of the two resulting subtrees, we can efficiently solve the problem. The key is to maintain the total sum and use it to derive the product for each potential split point, ensuring we take the result modulo \(10^9 + 7\) before returning it.

Medium/2026-01-07-1339-Maximum-Product-of-Splitted-Binary-Tree/solution.java

@@ -0,0 +1,33 @@
+class Solution {
+    private long totalSum = 0;
+    private long maxProduct = 0;
+    private final int MOD = 1000000007;
+
+    public int maxProduct(TreeNode root) {
+        totalSum = calculateSum(root);
+        calculateMaxProduct(root);
+        return (int) (maxProduct % MOD);
+    }
+
+    private long calculateSum(TreeNode node) {
+        if (node == null) return 0;
+        long leftSum = calculateSum(node.left);
+        long rightSum = calculateSum(node.right);
+        return node.val + leftSum + rightSum;
+    }
+
+    private long calculateMaxProduct(TreeNode node) {
+        if (node == null) return 0;
+        long leftSum = calculateMaxProduct(node.left);
+        long rightSum = calculateMaxProduct(node.right);
+        long currentSum = node.val + leftSum + rightSum;
+
+        if (leftSum > 0) {
+            maxProduct = Math.max(maxProduct, leftSum * (totalSum - leftSum));
+        }
+        if (rightSum > 0) {
+            maxProduct = Math.max(maxProduct, rightSum * (totalSum - rightSum));
+        }
+        return currentSum;
+    }
+}

Medium/2026-01-07-1339-Maximum-Product-of-Splitted-Binary-Tree/solution.js

@@ -0,0 +1,42 @@
+/**
+ * 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 maxProduct = function(root) {
+    const MOD = 1e9 + 7;
+    let totalSum = 0;
+    let maxProd = 0;
+
+    const calculateSum = (node) => {
+        if (!node) return 0;
+        const leftSum = calculateSum(node.left);
+        const rightSum = calculateSum(node.right);
+        const currentSum = leftSum + rightSum + node.val;
+        totalSum += currentSum;
+        return currentSum;
+    };
+
+    const findMaxProduct = (node) => {
+        if (!node) return 0;
+        const leftSum = findMaxProduct(node.left);
+        const rightSum = findMaxProduct(node.right);
+        const currentSum = leftSum + rightSum + node.val;
+        const otherSum = totalSum - currentSum;
+        maxProd = Math.max(maxProd, currentSum * otherSum);
+        return currentSum;
+    };
+
+    calculateSum(root);
+    findMaxProduct(root);
+    
+    return maxProd % MOD;
+};

Medium/2026-01-07-1339-Maximum-Product-of-Splitted-Binary-Tree/solution.py

@@ -0,0 +1,35 @@
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+class Solution:
+    def maxProduct(self, root: TreeNode) -> int:
+        MOD = 10**9 + 7
+        
+        def total_sum(node):
+            if not node:
+                return 0
+            return node.val + total_sum(node.left) + total_sum(node.right)
+        
+        total = total_sum(root)
+        max_product = 0
+        
+        def find_max_product(node):
+            nonlocal max_product
+            if not node:
+                return 0
+            left_sum = find_max_product(node.left)
+            right_sum = find_max_product(node.right)
+            current_sum = node.val + left_sum + right_sum
+            
+            if left_sum > 0:
+                max_product = max(max_product, left_sum * (total - left_sum))
+            if right_sum > 0:
+                max_product = max(max_product, right_sum * (total - right_sum))
+                
+            return current_sum
+        
+        find_max_product(root)
+        return max_product % MOD

README.md

@@ -328,3 +328,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-01-04 — [Four Divisors](https://leetcode.com/problems/four-divisors/) (Medium) → `Medium/2026-01-04-1390-Four-Divisors`
 - 2026-01-05 — [Maximum Matrix Sum](https://leetcode.com/problems/maximum-matrix-sum/) (Medium) → `Medium/2026-01-05-1975-Maximum-Matrix-Sum`
 - 2026-01-06 — [Maximum Level Sum of a Binary Tree](https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree/) (Medium) → `Medium/2026-01-06-1161-Maximum-Level-Sum-of-a-Binary-Tree`
+- 2026-01-07 — [Maximum Product of Splitted Binary Tree](https://leetcode.com/problems/maximum-product-of-splitted-binary-tree/) (Medium) → `Medium/2026-01-07-1339-Maximum-Product-of-Splitted-Binary-Tree`