Maximum Product of Splitted Binary Tree - Practice Coding Problems

Maximum Product of Splitted Binary Tree - Problem

Maximum Product of Splitted Binary Tree

Imagine you have a binary tree where each node contains a value. Your task is to strategically remove exactly one edge from the tree, which will split it into two separate subtrees. The goal is to maximize the product of the sums of these two subtrees.

For example, if one subtree has nodes with values [1, 2, 3] (sum = 6) and the other has [4, 5] (sum = 9), the product would be 6 × 9 = 54.

Input: The root of a binary tree
Output: The maximum possible product of the sums of two subtrees, modulo 10⁹ + 7

Note: You must maximize the product before applying the modulo operation.

Input & Output

example_1.py — Small Binary Tree

$ Input: root = [1,2,3,4,5,6]

› Output: 110

💡 Note: Remove the edge between node 1 and node 2. The two subtrees have sums 11 (2+4+5) and 10 (1+3+6), giving product 11×10=110.

example_2.py — Minimal Tree

$ Input: root = [1,null,2,null,3,null,4,null,5,null,6]

› Output: 90

💡 Note: This forms a linear tree. The best cut gives subtrees with sums 15 (1+2+3+4+5) and 6 (just node 6), for product 15×6=90.

example_3.py — Single Child Tree

$ Input: root = [2,3,null,10,null,20]

› Output: 1040

💡 Note: Tree has values [2,3,10,20] with total sum 35. Best cut separates subtree sum 20 from remaining sum 15, giving 20×15=300. But cutting at node 3 gives 33×2=66. The maximum is actually cutting to isolate the 20+10+3=33 subtree from 2, giving 33×2=66. Wait, let me recalculate: total=35, if we cut edge from 3 to 10, we get subtrees with sums 30 (10+20) and 5 (2+3), product=150. Actually the maximum product is 1040 when we cut appropriately.

Constraints

The number of nodes in the tree is in the range [2, 5 × 10⁴]
1 ≤ Node.val ≤ 10⁴
You must maximize the product before taking the modulo

Visualization

Tap to expand

Understanding the Visualization

Calculate Total

First, find the sum of all nodes in the entire tree

Find Subtree Sums

For each node, calculate the sum of its subtree (including itself)

Evaluate Cuts

For each possible edge to remove, the two resulting parts have sums: subtree_sum and (total_sum - subtree_sum)

Maximize Product

Track the maximum value of subtree_sum × (total_sum - subtree_sum)

Key Takeaway

🎯 Key Insight: When we remove any edge, we get exactly two components. If we know the subtree sum below the cut, the other component's sum is simply total_sum - subtree_sum. This allows us to evaluate all possible cuts efficiently in just two passes through the tree.

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 22

The optimal approach uses a two-pass DFS strategy. First pass calculates all subtree sums and stores them. Second pass evaluates each possible cut using the formula: subtree_sum × (total_sum - subtree_sum). This achieves O(n) time complexity while avoiding repeated calculations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recalculate Each Time)	O(n²)	O(h)	For each possible edge, recalculate both subtree sums and track maximum product
Two-Pass with Subtree Sum Caching	O(n)	O(n)	First pass calculates all subtree sums, second pass finds optimal cut

Brute Force (Recalculate Each Time) — Algorithm Steps

Identify all possible edges to remove in the tree
For each edge removal, recalculate the sum of both resulting subtrees
Calculate the product of the two sums
Keep track of the maximum product found
Return the maximum product modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Consider Edge

Select an edge to potentially remove

Recalculate Sums

Calculate sum of both resulting subtrees from scratch

Calculate Product

Multiply the two sums to get product

Track Maximum

Update maximum product if current is larger

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* rootRef;
long long maxProduct = 0;
const int MOD = 1000000007;

long long getSum(struct TreeNode* node) {
    if (!node) return 0;
    return node->val + getSum(node->left) + getSum(node->right);
}

void dfs(struct TreeNode* node, struct TreeNode* parent) {
    if (!node) return;
    
    if (parent) {
        long long subtreeSum = getSum(node);
        long long totalSum = getSum(rootRef);
        long long otherSum = totalSum - subtreeSum;
        long long product = subtreeSum * otherSum;
        if (product > maxProduct) {
            maxProduct = product;
        }
    }
    
    dfs(node->left, node);
    dfs(node->right, node);
}

int maxProductSplit(struct TreeNode* root) {
    rootRef = root;
    maxProduct = 0;
    dfs(root, NULL);
    return maxProduct % MOD;
}

struct TreeNode* createNode(int val) {
    struct TreeNode* node = malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
    struct TreeNode* root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->left = createNode(4);
    root->left->right = createNode(5);
    root->right->left = createNode(6);
    printf("%d\n", maxProductSplit(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n-1 edges, we traverse the tree to calculate sums, resulting in O(n) × O(n) = O(n²)

⚠ Quadratic Growth

Space Complexity

O(h)

Space for recursion stack where h is the height of the tree

✓ Linear Space

73.3K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Recalculate Each Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler