Path Sum III

Path Sum III - Problem

Given the root of a binary tree and an integer targetSum, return the number of paths where the sum of the values along the path equals targetSum.

The path does not need to start or end at the root or a leaf, but it must go downwards (i.e., traveling only from parent nodes to child nodes).

A path can start from any node and end at any descendant of that node, as long as the direction is always downward.

Input & Output

Example 1 — Basic Tree

$ Input: root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8

› Output: 3

💡 Note: Three paths sum to 8: (5→3), (5→2→1), and (-3→11)

Example 2 — Simple Tree

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

› Output: 3

💡 Note: Paths: (5→4→11→2), (5→8→4→5), and (4→11→7)

Example 3 — Single Node

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

› Output: 1

💡 Note: Only one node with value 1, which equals targetSum

Constraints

The number of nodes in the tree is in the range [0, 1000]
-10⁹ ≤ Node.val ≤ 10⁹
-1000 ≤ targetSum ≤ 1000

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 35 f Facebook 28 M Microsoft 22

The key insight is using prefix sums with a hash map to avoid redundant path calculations. Instead of checking every possible path separately, we track running sums during DFS and use the map to instantly find how many previous paths can combine with the current node to form valid paths. Best approach uses prefix sum technique with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Start from Every Node

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

Visit every node in the tree and for each node, explore all possible downward paths to count those that sum to the target. This requires checking every node as a potential starting point and then doing DFS from each.

Prefix Sum with Hash Map

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

Maintain running prefix sum during DFS traversal and use hash map to store frequency of each prefix sum. For any node, if (currentSum - targetSum) exists in map, we found valid path(s) ending at current node.

Brute Force - Start from Every Node — Algorithm Steps

Traverse every node in the tree
For each node, start a new path exploration
Use DFS to explore all downward paths from current node
Count paths that sum to targetSum

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Node

Pick any node as starting point

Explore Downward

DFS all paths going down only

Count Matches

Increment count when path sum equals target

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.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;
}

int dfsFromNode(struct TreeNode* node, long long target) {
    if (!node) return 0;
    
    int count = 0;
    if (node->val == target) {
        count += 1;
    }
    
    count += dfsFromNode(node->left, target - node->val);
    count += dfsFromNode(node->right, target - node->val);
    
    return count;
}

int solution(struct TreeNode* root, int targetSum) {
    if (!root) return 0;
    
    return dfsFromNode(root, targetSum) + 
           solution(root->left, targetSum) + 
           solution(root->right, targetSum);
}

struct TreeNode* buildTree(int* arr, int size) {
    if (size == 0) return NULL;
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode** queue = (struct TreeNode**)malloc(size * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    for (int i = 1; i < size; i += 2) {
        struct TreeNode* node = queue[front++];
        
        if (arr[i] != -1001) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        
        if (i + 1 < size && arr[i + 1] != -1001) {
            node->right = createNode(arr[i + 1]);
            queue[rear++] = node->right;
        }
    }
    
    free(queue);
    return root;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int size = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        if (strcmp(token, "null") == 0) {
            arr[size++] = -1001;
        } else {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n ");
    }
    
    int targetSum;
    scanf("%d", &targetSum);
    
    struct TreeNode* root = buildTree(arr, size);
    int result = solution(root, targetSum);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially explore n paths in worst case

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

⚡ Linearithmic Space

316.1K Views

High Frequency

~25 min Avg. Time

8.5K 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 - Start from Every Node — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler