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

Given a binary tree where each path going from the root to any leaf forms a valid sequence, check if a given string is a valid sequence in such binary tree.

We get the given string from the concatenation of an array of integers arr and the concatenation of all values of the nodes along a path results in a sequence in the given binary tree.

The goal is to determine if there exists a root-to-leaf path in the binary tree where the sequence of node values exactly matches the given array.

Input & Output

Example 1 — Valid Path Exists

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

› Output: true

💡 Note: The path 0 → 1 → 1 exists in the tree: starting from root(0), go left to node(1), then left again to leaf(1). This matches the sequence [0,1,1].

Example 2 — Path Exists But Not to Leaf

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

› Output: false

💡 Note: While the sequence [0,1] exists in the tree (root → left child), it doesn't end at a leaf node. The path must go from root to a leaf.

Example 3 — No Matching Path

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

› Output: true

💡 Note: The path 0 → 0 → 1 exists: from root(0), go right to node(0), then right again to leaf(1). This matches [0,0,1].

Constraints

1 ≤ nodes.length ≤ 5000
0 ≤ Node.val ≤ 9
1 ≤ arr.length ≤ 5000
0 ≤ arr[i] ≤ 9

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12 M Microsoft 8

The key insight is to use DFS with early termination when the current path doesn't match the target sequence. Best approach uses optimized DFS that terminates branches immediately when values don't match. Time: O(n), Space: O(h).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force DFS - Check All Paths

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

This approach generates all possible root-to-leaf paths in the binary tree and then checks if any of these paths exactly matches the given array sequence. We traverse the entire tree and collect all paths before comparison.

Optimized DFS with Early Termination

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

This approach uses depth-first search to traverse the tree while simultaneously checking if the current path matches the target sequence. We can terminate early when the current path diverges from the target, avoiding unnecessary exploration.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 1000

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;
}

struct TreeNode* buildTree(int* values, int size) {
    if (size == 0) return NULL;
    
    struct TreeNode* root = createNode(values[0]);
    struct TreeNode* queue[MAX_N];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < size) {
        struct TreeNode* current = queue[front++];
        
        // Left child
        if (i < size && values[i] != -1) {
            current->left = createNode(values[i]);
            queue[rear++] = current->left;
        }
        i++;
        
        // Right child
        if (i < size && values[i] != -1) {
            current->right = createNode(values[i]);
            queue[rear++] = current->right;
        }
        i++;
    }
    
    return root;
}

bool isValidSequence(struct TreeNode* root, int* arr, int arrSize, int index) {
    if (!root || index >= arrSize) {
        return false;
    }
    
    // Current node value doesn't match
    if (root->val != arr[index]) {
        return false;
    }
    
    // If we've reached the end of array, check if this is a leaf
    if (index == arrSize - 1) {
        return !root->left && !root->right;
    }
    
    // Continue checking left and right subtrees
    return isValidSequence(root->left, arr, arrSize, index + 1) ||
           isValidSequence(root->right, arr, arrSize, index + 1);
}

int parseArray(const char* str, int* arr) {
    int size = 0;
    const char* p = str;
    
    // Find opening bracket
    while (*p && *p != '[') p++;
    if (*p != '[') return 0;
    p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Check for null
        if (strncmp(p, "null", 4) == 0) {
            arr[size++] = -1;  // Use -1 to represent null
            p += 4;
        } else {
            char* endptr;
            arr[size++] = (int)strtol(p, &endptr, 10);
            p = endptr;
        }
    }
    
    return size;
}

void freeTree(struct TreeNode* root) {
    if (!root) return;
    freeTree(root->left);
    freeTree(root->right);
    free(root);
}

int main() {
    char line1[10000], line2[10000];
    
    // Read tree array
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    line1[strcspn(line1, "\n")] = 0;
    
    // Read sequence array
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    line2[strcspn(line2, "\n")] = 0;
    
    int treeValues[MAX_N];
    int treeSize = parseArray(line1, treeValues);
    
    int sequence[MAX_N];
    int sequenceSize = parseArray(line2, sequence);
    
    struct TreeNode* root = buildTree(treeValues, treeSize);
    
    bool result = false;
    if (root && sequenceSize > 0) {
        result = isValidSequence(root, sequence, sequenceSize, 0);
    }
    
    printf("%s\n", result ? "true" : "false");
    
    freeTree(root);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

32.4K Views

Medium Frequency

~15 min Avg. Time

892 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