Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree

Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree - Problem

Path Detective: Finding Valid Sequences in Binary Trees

Imagine you're a detective following clues through a maze-like tree structure. You have a binary tree where each node contains a single digit, and you need to determine if a given sequence of numbers forms a valid path from root to leaf.

Given:
• A root node of a binary tree where each node contains an integer value
• An array arr of integers representing a sequence

Your mission: Return true if there exists a path from the root to any leaf node such that the values along the path exactly match the given array sequence. The path must:
1. Start at the root node
2. End at a leaf node (node with no children)
3. Follow parent-child relationships in the tree
4. Match the array values in exact order

Think of it like following a treasure map - you must follow the exact sequence of landmarks to reach the treasure chest at the end!

Input & Output

example_1.py — Valid Path Found

$ Input: root = [1,0,1,null,1,0,null,null,1,0,null], arr = [1,0,1]

› Output: true

💡 Note: The path 1 → 0 → 1 exists from root to leaf and matches the target sequence [1,0,1] exactly.

example_2.py — No Valid Path

$ Input: root = [1,0,1,null,1,0,null,null,1,0,null], arr = [1,1,1]

› Output: false

💡 Note: No path from root to leaf matches [1,1,1]. The root is 1, but its children are 0 and 1, so we can't have 1→1 as the first two elements.

example_3.py — Path Doesn't End at Leaf

$ Input: root = [1,0,1,null,1,0,null,null,1,0,null], arr = [1,0]

› Output: false

💡 Note: The sequence [1,0] exists as a path from root, but it doesn't end at a leaf node. Valid sequences must reach a leaf.

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at the entrance (root) and check if it matches your first landmark

Follow Map

At each step, verify the current location matches your expected landmark

Smart Abandonment

If you reach a wrong landmark, abandon that path immediately - no need to continue

Treasure Check

Only claim success if you reach a dead-end AND have followed the complete map

Key Takeaway

🎯 Key Insight: By checking each node against our target sequence during traversal, we can eliminate invalid paths early and find valid sequences efficiently in O(n) time with minimal space usage.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to traverse all nodes, and potentially O(n) space per path with up to n paths in worst case

⚠ Quadratic Growth

Space Complexity

O(n²)

In worst case (skewed tree), we might store O(n) paths each of length O(n)

⚠ Quadratic Space

Constraints

The number of nodes in the tree is in the range [1, 5000]
1 ≤ Node.val ≤ 9
1 ≤ arr.length ≤ 50
0 ≤ arr[i] ≤ 9
All Node.val are digits
The tree is guaranteed to be a valid binary tree

Asked in

f Facebook 45 a Amazon 32 G Google 28 ⊞ Microsoft 19

The optimal solution uses DFS with early termination. We traverse the tree while simultaneously checking if each node matches the expected value in our target sequence. Key insights: (1) Terminate early when values don't match, (2) Only return true at leaf nodes when we've matched the complete sequence, (3) Use recursion to elegantly handle the tree traversal with minimal space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Paths)	O(n²)	O(n²)	Generate all root-to-leaf paths and check if any matches the target sequence
Optimized DFS (Early Termination)	O(n)	O(h)	Use DFS with early termination when path doesn't match sequence

Brute Force (Generate All Paths) — Algorithm Steps

Traverse the entire tree to collect all root-to-leaf paths
Store each path as a list of node values
Compare each collected path with the target array
Return true if any path matches exactly

Visualization

Tap to expand

Step-by-Step Walkthrough

Traverse Tree

Generate all root-to-leaf paths by exploring every branch

Store Paths

Keep all paths in memory as arrays of values

Compare

Check each stored path against target sequence

Code -

solution.c — C

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

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

#define MAX_PATHS 1000
#define MAX_DEPTH 1000

int allPaths[MAX_PATHS][MAX_DEPTH];
int pathLengths[MAX_PATHS];
int pathCount = 0;
int currentPath[MAX_DEPTH];
int currentDepth = 0;

void generatePaths(struct TreeNode* node) {
    if (!node) return;
    
    currentPath[currentDepth++] = node->val;
    
    if (!node->left && !node->right) {
        // Copy current path to allPaths
        for (int i = 0; i < currentDepth; i++) {
            allPaths[pathCount][i] = currentPath[i];
        }
        pathLengths[pathCount] = currentDepth;
        pathCount++;
    } else {
        generatePaths(node->left);
        generatePaths(node->right);
    }
    
    currentDepth--;
}

bool isValidSequence(struct TreeNode* root, int* arr, int arrSize) {
    if (!root || arrSize == 0) {
        return false;
    }
    
    pathCount = 0;
    currentDepth = 0;
    generatePaths(root);
    
    for (int i = 0; i < pathCount; i++) {
        if (pathLengths[i] == arrSize) {
            bool matches = true;
            for (int j = 0; j < arrSize; j++) {
                if (allPaths[i][j] != arr[j]) {
                    matches = false;
                    break;
                }
            }
            if (matches) return true;
        }
    }
    
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to traverse all nodes, and potentially O(n) space per path with up to n paths in worst case

⚠ Quadratic Growth

Space Complexity

O(n²)

In worst case (skewed tree), we might store O(n) paths each of length O(n)

⚠ Quadratic Space

Constraints

The number of nodes in the tree is in the range [1, 5000]
1 ≤ Node.val ≤ 9
1 ≤ arr.length ≤ 50
0 ≤ arr[i] ≤ 9
All Node.val are digits
The tree is guaranteed to be a valid binary tree

42.4K Views

Medium Frequency

~18 min Avg. Time

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

Brute Force (Generate All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler