Path Sum II

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,5,1], targetSum = 22

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

💡 Note: There are two paths whose sum equals 22: 5+4+11+2=22 and 5+8+4+5=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

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

✓ Optimized DFS with Backtracking (Optimal)

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

This is the optimal approach that uses depth-first search with backtracking. We maintain a running sum as we traverse the tree and only add paths to our result when we reach a leaf node and the sum equals our target. This eliminates the need to generate unnecessary paths.

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>
#include <string.h>

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

static int** globalResult;
static int* globalColumnSizes;
static int globalResultSize;

void dfs(struct TreeNode* node, int* currentPath, int pathLen, int currentSum, int targetSum) {
    if (!node) return;

    currentPath[pathLen] = node->val;
    currentSum += node->val;
    pathLen++;

    if (!node->left && !node->right && currentSum == targetSum) {
        globalResult[globalResultSize] = (int*)malloc(pathLen * sizeof(int));
        for (int i = 0; i < pathLen; i++) {
            globalResult[globalResultSize][i] = currentPath[i];
        }
        globalColumnSizes[globalResultSize] = pathLen;
        globalResultSize++;
    }

    dfs(node->left, currentPath, pathLen, currentSum, targetSum);
    dfs(node->right, currentPath, pathLen, currentSum, targetSum);
}

int** pathSum(struct TreeNode* root, int targetSum, int* returnSize, int** returnColumnSizes) {
    globalResultSize = 0;
    *returnSize = 0;
    if (!root) return NULL;

    globalResult = (int**)malloc(1000 * sizeof(int*));
    globalColumnSizes = (int*)malloc(1000 * sizeof(int));
    int* currentPath = (int*)malloc(1000 * sizeof(int));

    dfs(root, currentPath, 0, 0, targetSum);

    *returnSize = globalResultSize;
    *returnColumnSizes = globalColumnSizes;

    free(currentPath);
    return globalResult;
}

struct TreeNode* buildTree(char** values, int size) {
    if (size == 0 || values[0] == NULL || strcmp(values[0], "null") == 0 || strlen(values[0]) == 0) {
        return NULL;
    }

    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = atoi(values[0]);
    root->left = root->right = NULL;

    struct TreeNode** queue = (struct TreeNode**)malloc(size * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    queue[rear++] = root;

    int i = 1;
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];

        if (i < size) {
            if (values[i] != NULL && strcmp(values[i], "null") != 0 && strlen(values[i]) > 0) {
                node->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
                node->left->val = atoi(values[i]);
                node->left->left = node->left->right = NULL;
                queue[rear++] = node->left;
            }
            i++;
        }

        if (i < size) {
            if (values[i] != NULL && strcmp(values[i], "null") != 0 && strlen(values[i]) > 0) {
                node->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
                node->right->val = atoi(values[i]);
                node->right->left = node->right->right = NULL;
                queue[rear++] = node->right;
            }
            i++;
        }
    }

    free(queue);
    return root;
}

void trimToken(char* token) {
    // Remove leading brackets and spaces
    while (*token == ' ' || *token == '[' || *token == ']') {
        memmove(token, token + 1, strlen(token));
    }
    // Remove trailing brackets, spaces, and newlines
    int len = strlen(token);
    while (len > 0 && (token[len - 1] == ' ' || token[len - 1] == '[' || token[len - 1] == ']' || token[len - 1] == '\n' || token[len - 1] == '\r')) {
        token[--len] = '\0';
    }
}

int main() {
    char treeInput[10000];
    int targetSum;

    fgets(treeInput, sizeof(treeInput), stdin);

    char line2[100];
    fgets(line2, sizeof(line2), stdin);
    targetSum = atoi(line2);

    char** values = (char**)malloc(1000 * sizeof(char*));
    int valueCount = 0;

    // Manual parsing to handle empty tokens correctly
    char* str = treeInput;
    int len = strlen(str);
    
    // Remove brackets and trim
    char* start = str;
    while (*start && (*start == '[' || *start == ' ')) start++;
    char* end = start + strlen(start) - 1;
    while (end > start && (*end == ']' || *end == ' ' || *end == '\n' || *end == '\r')) {
        *end = '\0';
        end--;
    }
    
    // Parse tokens, preserving empty ones
    char* p = start;
    char* tokenStart = p;
    
    while (*p) {
        if (*p == ',') {
            // Found a token
            values[valueCount] = (char*)malloc(100 * sizeof(char));
            int tokenLen = p - tokenStart;
            strncpy(values[valueCount], tokenStart, tokenLen);
            values[valueCount][tokenLen] = '\0';
            
            // Trim spaces from this token
            char* trim = values[valueCount];
            while (*trim == ' ') trim++;
            if (trim != values[valueCount]) {
                memmove(values[valueCount], trim, strlen(trim) + 1);
            }
            int trimLen = strlen(values[valueCount]);
            while (trimLen > 0 && values[valueCount][trimLen - 1] == ' ') {
                values[valueCount][--trimLen] = '\0';
            }
            
            valueCount++;
            tokenStart = p + 1;
        }
        p++;
    }
    
    // Handle the last token
    if (tokenStart < p) {
        values[valueCount] = (char*)malloc(100 * sizeof(char));
        strcpy(values[valueCount], tokenStart);
        
        // Trim spaces from this token
        char* trim = values[valueCount];
        while (*trim == ' ') trim++;
        if (trim != values[valueCount]) {
            memmove(values[valueCount], trim, strlen(trim) + 1);
        }
        int trimLen = strlen(values[valueCount]);
        while (trimLen > 0 && values[valueCount][trimLen - 1] == ' ') {
            values[valueCount][--trimLen] = '\0';
        }
        
        valueCount++;
    }

    struct TreeNode* root = buildTree(values, valueCount);

    int returnSize;
    int* returnColumnSizes;
    int** result = pathSum(root, targetSum, &returnSize, &returnColumnSizes);

    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");

    for (int i = 0; i < returnSize; i++) free(result[i]);
    free(result);
    free(returnColumnSizes);
    for (int i = 0; i < valueCount; i++) free(values[i]);
    free(values);

    return 0;
}

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