Binary Tree Maximum Path Sum - Practice Coding Problems

Binary Tree Maximum Path Sum - Problem

Binary Tree Maximum Path Sum - Find the path with the largest sum of node values in any binary tree.

A path in a binary tree is a sequence of connected nodes where you can move from parent to child or child to parent. The path doesn't need to start or end at the root - it can be any connected sequence of nodes. Each node can appear at most once in the path.

Your task is to find the path with the maximum sum of node values. The path must contain at least one node.

Examples:
• Tree: [1,2,3] → Maximum path sum: 6 (path: 2→1→3)
• Tree: [-10,9,20,null,null,15,7] → Maximum path sum: 42 (path: 15→20→7)

Goal: Return the maximum sum of any valid path in the binary tree.

Input & Output

example_1.py — Basic Tree

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

› Output: 6

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

example_2.py — 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. We skip the negative root -10.

example_3.py — Single Node

$ Input: root = [-3]

› Output: -3

💡 Note: The tree has only one node, so the maximum path sum is -3 (we must include at least one node).

Constraints

The number of nodes in the tree is in the range [1, 3 × 10⁴]
-1000 ≤ Node.val ≤ 1000
The tree is guaranteed to be non-empty
Path must contain at least one node

Visualization

Tap to expand

Understanding the Visualization

Identify the Problem

We need to find any path (not necessarily root to leaf) with maximum sum

Key Insight

At each node, track two things: max path through this node, and max path extending upward

Handle Negatives

Use max(0, childSum) to ignore paths that decrease our total

Global Maximum

Keep track of the best path found anywhere in the tree

Key Takeaway

🎯 Key Insight: The optimal solution elegantly handles the constraint that each node appears at most once by separating the calculation of paths passing through a node (for global maximum) versus paths extending upward to parent nodes (for recursive returns).

Asked in

G Google 52 a Amazon 41 f Meta 33 ⊞ Microsoft 28

The optimal solution uses a single DFS traversal with a key insight: at each node, calculate both the maximum path passing through the node (for global tracking) and the maximum path extending upward (for parent nodes). Use max(0, childSum) to ignore negative contributions, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Possible Paths)	O(n³)	O(n)	Generate all possible paths and find the one with maximum sum
Single-Pass DFS (Optimal)	O(n)	O(h)	Use DFS with memoization to solve in one pass by tracking max path through each node

Brute Force (All Possible Paths) — Algorithm Steps

For each node in the tree, use it as a potential path start
From each starting node, perform DFS to explore all reachable paths
For each path, calculate the sum of node values
Track the maximum sum found across all paths
Return the global maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Node 1

Begin path exploration from the first node

Explore All Paths

Try every possible path combination from this starting point

Calculate Sums

Compute the sum for each complete path

Track Maximum

Keep track of the highest sum found so far

Repeat for All Nodes

Repeat the entire process for every node as starting point

Code -

solution.c — C

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

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

int maxSum = INT_MIN;

void dfsPath(struct TreeNode* node, struct TreeNode** visited, int visitedCount, int currentSum) {
    if (currentSum > maxSum) {
        maxSum = currentSum;
    }
    
    struct TreeNode* children[2] = {node->left, node->right};
    
    for (int i = 0; i < 2; i++) {
        if (children[i] != NULL) {
            // Check if already visited
            int alreadyVisited = 0;
            for (int j = 0; j < visitedCount; j++) {
                if (visited[j] == children[i]) {
                    alreadyVisited = 1;
                    break;
                }
            }
            
            if (!alreadyVisited) {
                visited[visitedCount] = children[i];
                dfsPath(children[i], visited, visitedCount + 1, currentSum + children[i]->val);
            }
        }
    }
}

int maxPathSum(struct TreeNode* root) {
    if (root == NULL) return 0;
    
    maxSum = INT_MIN;
    
    // Simple implementation - in practice would need dynamic node collection
    struct TreeNode* visited[1000];
    visited[0] = root;
    dfsPath(root, visited, 1, root->val);
    
    return maxSum;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n nodes, we might explore O(n²) possible paths in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to tree height, plus path storage

⚡ Linearithmic Space

127.3K 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 Possible Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler