Equal Tree Partition

Equal Tree Partition - Problem

Given the root of a binary tree, return true if you can partition the tree into two trees with equal sums of values after removing exactly one edge on the original tree.

A partition means dividing the tree into two separate connected components. When you remove an edge, you get two subtrees - the removed subtree and the remaining tree. Both must have the same sum of node values.

Note: You cannot remove the edge above the root node (since there isn't one).

Input & Output

Example 1 — Valid Partition

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

› Output: true

💡 Note: Original tree sum = 5+10+10+2+3 = 30. We can remove the edge above the right subtree (10,2,3) which has sum 15, leaving the left part (5,10) with sum 15. Both parts have equal sum 15.

Example 2 — No Valid Partition

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

› Output: false

💡 Note: Original tree sum = 1+2+10+2+20 = 35. Since 35 is odd, we cannot split it into two equal parts. Any partition would result in unequal sums.

Example 3 — Single Split Works

$ Input: root = [2,1,1]

› Output: false

💡 Note: Tree sum = 2+1+1 = 4. Target sum for each partition would be 2. However, the left subtree has sum 1 and the right subtree has sum 1. Neither subtree has the required sum of 2, so no valid partition exists.

Constraints

The number of nodes in the tree is in the range [1, 10⁴].
-10⁵ ≤ Node.val ≤ 10⁵

Visualization

Tap to expand

Asked in

f Facebook 25 a Amazon 15 M Microsoft 12

The key insight is that we can partition a tree into two equal-sum parts if any subtree has exactly half the total sum. The optimal approach uses DFS to calculate all subtree sums in O(n) time and checks if any equals totalSum/2. Time: O(n), Space: O(n).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Calculate All Subtree Sums

⏱️ Time: O(n²) Space: O(h)

First calculate the total sum of all nodes in the tree. Then for each node (except root), calculate its subtree sum. If any subtree sum equals half the total sum, we can remove the edge above that node to create equal partitions.

DFS with Memoization

⏱️ Time: O(n) Space: O(n)

Calculate all subtree sums in a single DFS traversal. During the traversal, store subtree sums and check if any equals half the total sum. This avoids recalculating the same subtree sums multiple times.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

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

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

// Parse the input array and build the tree
TreeNode* buildTree(char* input) {
    if (!input || strlen(input) <= 2) return NULL;
    
    // Remove brackets
    char* str = input + 1;
    str[strlen(str) - 1] = '\0';
    
    if (strlen(str) == 0) return NULL;
    
    // Parse nodes into array
    char* nodes[1000];
    int nodeCount = 0;
    
    char* token = strtok(str, ",");
    while (token != NULL && nodeCount < 1000) {
        // Remove leading/trailing spaces
        while (*token == ' ') token++;
        char* end = token + strlen(token) - 1;
        while (end > token && *end == ' ') {
            *end = '\0';
            end--;
        }
        nodes[nodeCount++] = token;
        token = strtok(NULL, ",");
    }
    
    if (nodeCount == 0) return NULL;
    
    // Build tree using queue (level order)
    TreeNode* queue[1000];
    int front = 0, rear = 0;
    
    TreeNode* root = createNode(atoi(nodes[0]));
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < nodeCount) {
        TreeNode* current = queue[front++];
        
        // Left child
        if (i < nodeCount && strcmp(nodes[i], "null") != 0) {
            current->left = createNode(atoi(nodes[i]));
            queue[rear++] = current->left;
        }
        i++;
        
        // Right child
        if (i < nodeCount && strcmp(nodes[i], "null") != 0) {
            current->right = createNode(atoi(nodes[i]));
            queue[rear++] = current->right;
        }
        i++;
    }
    
    return root;
}

// Calculate total sum of tree
long long calculateSum(TreeNode* root) {
    if (!root) return 0;
    return root->val + calculateSum(root->left) + calculateSum(root->right);
}

// DFS to check if any subtree has target sum
bool found = false;

long long dfs(TreeNode* root, long long target) {
    if (!root) return 0;
    
    long long leftSum = dfs(root->left, target);
    long long rightSum = dfs(root->right, target);
    long long currentSum = root->val + leftSum + rightSum;
    
    // Check if removing left subtree gives equal partition
    if (root->left && leftSum == target) {
        found = true;
    }
    
    // Check if removing right subtree gives equal partition
    if (root->right && rightSum == target) {
        found = true;
    }
    
    return currentSum;
}

bool checkEqualTreePartition(TreeNode* root) {
    if (!root) return false;
    
    long long totalSum = calculateSum(root);
    
    // If total sum is odd, cannot partition equally
    if (totalSum % 2 != 0) return false;
    
    found = false;
    dfs(root, totalSum / 2);
    
    return found;
}

void freeTree(TreeNode* root) {
    if (!root) return;
    freeTree(root->left);
    freeTree(root->right);
    free(root);
}

int main() {
    char input[10000];
    
    if (fgets(input, sizeof(input), stdin)) {
        // Remove newline
        input[strcspn(input, "\n")] = '\0';
        
        // Make a copy for parsing since strtok modifies the string
        char* inputCopy = (char*)malloc(strlen(input) + 1);
        strcpy(inputCopy, input);
        
        TreeNode* root = buildTree(inputCopy);
        
        bool result = checkEqualTreePartition(root);
        
        printf("%s\n", result ? "true" : "false");
        
        freeTree(root);
        free(inputCopy);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

87.5K Views

Medium Frequency

~25 min Avg. Time

891 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