Binary Tree Maximum Path Sum

Binary Tree Maximum Path Sum - Problem

A path in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence at most once. Note that the path does not need to pass through the root.

The path sum of a path is the sum of the node's values in the path.

Given the root of a binary tree, return the maximum path sum of any non-empty path.

Input & Output

Example 1 — Basic Tree with Positive Values

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

› Output: 6

💡 Note: The optimal path is 2 → 1 → 3 with sum = 2 + 1 + 3 = 6

Example 2 — Tree with Negative Values

$ Input: root = [-10,9,20,null,null,15,7]

› Output: 42

💡 Note: The optimal path is 15 → 20 → 7 with sum = 15 + 20 + 7 = 42

Example 3 — Single Node

$ Input: root = [-3]

› Output: -3

💡 Note: The tree has only one node, so the maximum path sum is -3

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is that for each node, the maximum path sum either passes through that node or lies entirely within one of its subtrees. The optimal DFS approach calculates the maximum path at each node by considering left subtree + node + right subtree. Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Brute Force - All Paths Enumeration

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

For every pair of nodes, find the path between them and calculate the sum. This involves exploring all possible paths in the tree, which is extremely inefficient.

DFS with Global Maximum

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

For each node, calculate the maximum path sum that can be achieved by paths passing through that node. Use DFS to compute the maximum contribution from left and right subtrees.

Brute Force - All Paths Enumeration — Algorithm Steps

For each node as starting point
For each other node as ending point
Find path between them and calculate sum
Track maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All Nodes

Collect all nodes in the tree

Generate Pairs

Create all possible node pairs

Calculate Paths

Find path sum for each pair and track maximum

Code -

solution.c — C

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

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

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

static struct TreeNode* nodes[30000];
static int nodeCount = 0;
static int maxPathSum = INT_MIN;

void getAllNodes(struct TreeNode* node) {
    if (!node) return;
    nodes[nodeCount++] = node;
    getAllNodes(node->left);
    getAllNodes(node->right);
}

void dfs(struct TreeNode* node, int currentSum, int pathLength, int visited[]) {
    if (!node) return;
    
    // Mark current node as visited
    int nodeIndex = -1;
    for (int i = 0; i < nodeCount; i++) {
        if (nodes[i] == node) {
            nodeIndex = i;
            break;
        }
    }
    
    if (nodeIndex == -1 || visited[nodeIndex]) return;
    
    visited[nodeIndex] = 1;
    currentSum += node->val;
    
    // Update max path sum
    if (currentSum > maxPathSum) {
        maxPathSum = currentSum;
    }
    
    // Try children
    if (node->left) {
        dfs(node->left, currentSum, pathLength + 1, visited);
    }
    if (node->right) {
        dfs(node->right, currentSum, pathLength + 1, visited);
    }
    
    // Try connected nodes (parent relationship)
    for (int i = 0; i < nodeCount; i++) {
        if (!visited[i]) {
            struct TreeNode* otherNode = nodes[i];
            if (otherNode->left == node || otherNode->right == node ||
                node->left == otherNode || node->right == otherNode) {
                dfs(otherNode, currentSum, pathLength + 1, visited);
            }
        }
    }
    
    // Backtrack
    visited[nodeIndex] = 0;
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    
    nodeCount = 0;
    maxPathSum = INT_MIN;
    getAllNodes(root);
    
    // Try starting from each node
    for (int i = 0; i < nodeCount; i++) {
        int visited[30000] = {0};
        dfs(nodes[i], 0, 0, visited);
    }
    
    return maxPathSum;
}

struct TreeNode* buildTree(char* s) {
    if (!s || strlen(s) < 3) return NULL;
    
    // Remove brackets and parse
    int len = strlen(s);
    if (s[0] == '[' && s[len-1] == ']') {
        s[len-1] = '\0';
        s++;
    }
    
    if (strlen(s) == 0) return NULL;
    
    // Simple parsing for array elements
    int vals[30000];
    int isNull[30000];
    int count = 0;
    
    char* token = strtok(s, ",");
    while (token && count < 30000) {
        // Remove whitespace
        while (*token == ' ') token++;
        
        if (strncmp(token, "null", 4) == 0) {
            isNull[count] = 1;
        } else {
            isNull[count] = 0;
            vals[count] = atoi(token);
        }
        count++;
        token = strtok(NULL, ",");
    }
    
    if (count == 0 || isNull[0]) return NULL;
    
    struct TreeNode* root = createNode(vals[0]);
    struct TreeNode* queue[30000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < count) {
        struct TreeNode* node = queue[front++];
        
        if (i < count && !isNull[i]) {
            node->left = createNode(vals[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < count && !isNull[i]) {
            node->right = createNode(vals[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    struct TreeNode* root = buildTree(input);
    printf("%d\n", solution(root));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs of nodes, O(n) to find path between each pair

✓ Linear Growth

Space Complexity

O(n)

Recursion stack and path storage

✓ Linear Space

68.5K Views

High Frequency

~25 min Avg. Time

2.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 - All Paths Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler