Why Path Sum Root to Leaf in Binary Tree in DSA C++?

The Big Idea

What if you could instantly know if a path adds up to your target without checking every step yourself?

The Scenario

Imagine you have a family tree drawn on paper, and you want to find if there is a path from the oldest ancestor to a youngest family member where the ages add up to a certain number.

Doing this by checking every possible path manually is tiring and confusing.

The Problem

Manually adding ages along each path is slow and easy to make mistakes.

You might forget a branch or add wrong numbers, especially if the tree is big.

It's hard to keep track of all paths and sums without a clear method.

The Solution

Using a program to check the tree automatically saves time and avoids errors.

The program walks down each path, adding numbers as it goes, and stops when it finds a path with the right sum.

This way, you get a clear yes or no answer quickly.

Before vs After

✗ Before

int sum = 0;
// Manually add values for each path
sum = 5 + 4 + 11 + 2;
if (sum == target) return true;

✓ After

bool hasPathSum(TreeNode* root, int targetSum) {
  if (!root) return false;
  if (!root->left && !root->right) return root->val == targetSum;
  return hasPathSum(root->left, targetSum - root->val) || hasPathSum(root->right, targetSum - root->val);
}

What It Enables

This lets you quickly find if any root-to-leaf path adds up to a target, even in big trees.

Real Life Example

Checking if a route in a map has a total distance equal to a target number by adding distances between stops.

Key Takeaways

Manual checking is slow and error-prone.

Recursive path sum checking is fast and reliable.

Useful for any problem needing path sum verification in trees.