Path Sum III - Practice Coding Problems

Path Sum III - Problem

You're given the root of a binary tree and an integer targetSum. Your mission is to find the total number of downward paths in the tree where the sum of node values equals the target sum.

Here's the twist: paths don't need to start at the root or end at a leaf! Any downward path (parent to child) that sums to the target counts. Think of it like finding all the "treasure paths" in a tree where each path's gold coins add up to exactly your target amount.

Example: In a tree with nodes [10,5,-3,3,2,null,11,3,-2,null,1], if targetSum = 8, you might find paths like [5,3], [5,2,1], or even [-3,11] that all sum to 8.

Goal: Return the count of all valid downward paths that sum to targetSum.

Input & Output

example_1.py — Standard Tree

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

› Output: 3

💡 Note: The paths that sum to 8 are: [5,3], [5,2,1], and [-3,11]. Note how these paths can start and end at any nodes as long as they go downward.

example_2.py — Simple Path

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

› Output: 3

💡 Note: The paths that sum to 22 are: [5,4,11,2], [5,8,4,5], and [4,11,7]. Multiple valid downward paths exist in this tree.

example_3.py — Edge Case

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

› Output: 1

💡 Note: Single node tree where the root itself equals the target sum, so there's exactly one valid path.

Visualization

Tap to expand

Understanding the Visualization

Start hiking with GPS

Begin DFS traversal while GPS tracks cumulative elevation (prefix sum)

Check for trail segments

At each point, GPS checks if any previous checkpoint creates valid trail to current position

Record and backtrack

Count valid trails, update GPS with current position, then remove it when backtracking

Key Takeaway

🎯 Key Insight: Prefix sum + HashMap transforms O(n²) brute force into O(n) optimal solution by remembering path sums and using mathematical relationships

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during DFS traversal

✓ Linear Growth

Space Complexity

O(n)

HashMap can store up to O(n) prefix sums in worst case, plus O(h) recursion stack

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [0, 1000]
Each node value is in range [-10⁹, 10⁹]
targetSum is in range [-1000, 1000]
Path must go downward (parent to child direction only)

Asked in

a Amazon 45 f Facebook 38 ⊞ Microsoft 32 G Google 28 Apple 22

The optimal solution uses prefix sum with HashMap technique. As we traverse the tree with DFS, we maintain running path sums and store them in a HashMap. At each node, we check if (currentSum - targetSum) exists in the map - if it does, there are valid paths ending at current node. The key insight is that prefix[j] - prefix[i] = sum from i to j, allowing us to find all valid subpaths efficiently in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum with HashMap (Optimal)	O(n)	O(n)	Use prefix sums and HashMap to find valid paths in single DFS traversal
Brute Force (Try Every Starting Point)	O(n²)	O(h)	For each node, explore all downward paths and count those that sum to target

Prefix Sum with HashMap (Optimal) — Algorithm Steps

Perform DFS traversal while maintaining current path sum
At each node, check if (currentSum - targetSum) exists in HashMap
Add current prefix sum to HashMap before exploring children
Use backtracking to remove current sum when returning from recursion
Initialize HashMap with {0: 1} to handle paths starting from any node

Visualization

Tap to expand

Step-by-Step Walkthrough

Track prefix sums

Maintain running sum from root to current node

Check for valid paths

Look for (currentSum - target) in HashMap

Backtrack HashMap

Remove current sum when returning from recursion

Code -

solution.c — C

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

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

// Simple hash table for demonstration
#define HASH_SIZE 10007

struct HashEntry {
    long key;
    int value;
    struct HashEntry* next;
};

struct HashEntry* hashTable[HASH_SIZE];

int hash(long key) {
    return ((key % HASH_SIZE) + HASH_SIZE) % HASH_SIZE;
}

void putHash(long key, int value) {
    int idx = hash(key);
    struct HashEntry* entry = hashTable[idx];
    while (entry && entry->key != key) {
        entry = entry->next;
    }
    if (entry) {
        entry->value = value;
    } else {
        struct HashEntry* newEntry = malloc(sizeof(struct HashEntry));
        newEntry->key = key;
        newEntry->value = value;
        newEntry->next = hashTable[idx];
        hashTable[idx] = newEntry;
    }
}

int getHash(long key) {
    int idx = hash(key);
    struct HashEntry* entry = hashTable[idx];
    while (entry && entry->key != key) {
        entry = entry->next;
    }
    return entry ? entry->value : 0;
}

int dfs(struct TreeNode* node, long currentSum, int targetSum) {
    if (!node) return 0;
    
    currentSum += node->val;
    int count = getHash(currentSum - targetSum);
    
    putHash(currentSum, getHash(currentSum) + 1);
    
    count += dfs(node->left, currentSum, targetSum);
    count += dfs(node->right, currentSum, targetSum);
    
    putHash(currentSum, getHash(currentSum) - 1);
    
    return count;
}

int pathSum(struct TreeNode* root, int targetSum) {
    memset(hashTable, 0, sizeof(hashTable));
    putHash(0, 1);
    return dfs(root, 0, targetSum);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during DFS traversal

✓ Linear Growth

Space Complexity

O(n)

HashMap can store up to O(n) prefix sums in worst case, plus O(h) recursion stack

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [0, 1000]
Each node value is in range [-10⁹, 10⁹]
targetSum is in range [-1000, 1000]
Path must go downward (parent to child direction only)

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Prefix Sum with HashMap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler