Path Sum II - Practice Coding Problems

Path Sum II - Problem

Path Sum II is a classic tree traversal problem that challenges you to find all root-to-leaf paths in a binary tree where the sum equals a target value.

🎯 Your Mission: Given a binary tree and a target sum, discover every possible path from root to leaf where the node values add up exactly to your target.

📋 What You're Given:
• root - The root node of a binary tree
• targetSum - An integer representing your target sum

📤 What You Return:
• A list of lists, where each inner list contains the node values of a valid path
• Each path must start at the root and end at a leaf node
• The sum of values in each path must equal targetSum

🌳 Remember: A leaf node has no children, and you need the actual node values, not references!

Input & Output

example_1.py — Basic Tree

$ Input: root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22

› Output: [[5,4,11,2],[5,8,4,1]]

💡 Note: There are two paths whose sum equals 22: 5+4+11+2=22 and 5+8+4+1=22. Both start from root and end at leaf nodes.

example_2.py — Single Node

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

› Output: []

💡 Note: No root-to-leaf path sums to 5. The paths are [1,2] (sum=3) and [1,3] (sum=4).

example_3.py — Single Node Match

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

› Output: [[1]]

💡 Note: The only path is [1] which sums to 1, matching our target.

Constraints

The number of nodes in the tree is in the range [0, 5000]
−1000 ≤ Node.val ≤ 1000
−1000 ≤ targetSum ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at the mountain base (root) with full energy budget

Follow Trails

At each junction, spend energy (add node value) and choose a path

Reach Summit

When you reach a dead-end trail (leaf), check if energy spent equals budget

Backtrack

Return to previous junction to explore other trails

Key Takeaway

🎯 Key Insight: Backtracking allows us to explore all possible paths efficiently by building solutions incrementally and undoing choices when we need to try different alternatives.

Asked in

A Amazon 45 ⊞ Microsoft 38 G Google 35 f Meta 28

The optimal solution uses DFS with backtracking to efficiently find all root-to-leaf paths that sum to the target. Key insights: maintain a running sum during traversal, use backtracking to explore all paths, and only store paths when reaching valid leaf nodes. Time complexity: O(n) where n is the number of nodes.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DFS with Backtracking (Optimal)	O(n)	O(h)	Use DFS with running sum and backtracking to find valid paths efficiently

Optimized DFS with Backtracking (Optimal) — Algorithm Steps

Start DFS from root with current path and running sum
Add current node to path and update running sum
If at leaf node and sum equals target, add path to result
Recursively explore left and right subtrees
Backtrack by removing current node from path

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at root with empty path and sum=0

Add Node

Add current node to path and update sum

Check Leaf

If leaf and sum equals target, save path

Backtrack

Remove current node and try other paths

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void dfs(struct TreeNode* node, int* currentPath, int pathLen, int currentSum, 
        int targetSum, int** result, int* returnSize, int** returnColumnSizes) {
    if (!node) return;
    
    // Add current node to path and sum
    currentPath[pathLen] = node->val;
    currentSum += node->val;
    pathLen++;
    
    // If leaf node and sum matches target
    if (!node->left && !node->right && currentSum == targetSum) {
        result[*returnSize] = (int*)malloc(pathLen * sizeof(int));
        for (int i = 0; i < pathLen; i++) {
            result[*returnSize][i] = currentPath[i];
        }
        (*returnColumnSizes)[*returnSize] = pathLen;
        (*returnSize)++;
    }
    
    // Recursively explore children
    dfs(node->left, currentPath, pathLen, currentSum, targetSum, result, returnSize, returnColumnSizes);
    dfs(node->right, currentPath, pathLen, currentSum, targetSum, result, returnSize, returnColumnSizes);
}

int** pathSum(struct TreeNode* root, int targetSum, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (!root) return NULL;
    
    int** result = (int**)malloc(1000 * sizeof(int*));
    *returnColumnSizes = (int*)malloc(1000 * sizeof(int));
    int* currentPath = (int*)malloc(1000 * sizeof(int));
    
    dfs(root, currentPath, 0, 0, targetSum, result, returnSize, returnColumnSizes);
    
    free(currentPath);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node once. In worst case, we might need to copy O(n) paths, each of length O(log n) to O(n)

✓ Linear Growth

Space Complexity

O(h)

Recursion depth is limited by tree height h. Additional space for storing result paths

✓ Linear Space

68.3K Views

High Frequency

~15 min Avg. Time

2.2K 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

Optimized DFS with Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler