Binary Tree Longest Consecutive Sequence II

Binary Tree Longest Consecutive Sequence II - Problem

Binary Tree Longest Consecutive Sequence II

You are given the root of a binary tree. Your task is to find the length of the longest consecutive path in the tree.

A consecutive path is defined as a path where the values of consecutive nodes differ by exactly 1. This path can be either:
• Increasing: [1,2,3,4]
• Decreasing: [4,3,2,1]

The key twist is that the path can follow a child-Parent-child pattern, not just parent-child. This means the longest path might go up from a leaf, through ancestors, then down to another leaf.

Goal: Return the length of the longest consecutive sequence in the tree.

Example: In a tree with nodes [2,1,3], the consecutive paths are [1,2,3] (length 3) going from left child → parent → right child.

Input & Output

example_1.py — Python

$ Input: [1,2,3]

› Output: 2

💡 Note: The longest consecutive path is [1,2] or [2,3], both have length 2. The tree structure is: 1 as root, 2 as left child, 3 as right child.

example_2.py — Python

$ Input: [2,1,3]

› Output: 3

💡 Note: The longest consecutive path is [1,2,3] with length 3. This path goes: left child (1) → parent (2) → right child (3), demonstrating the child-parent-child pattern.

example_3.py — Python

$ Input: [1]

› Output: 1

💡 Note: Single node tree has only one possible path of length 1, which is the node itself.

Constraints

The number of nodes in the tree is in the range [0, 3 * 10⁴]
-3 * 10⁴ <= Node.val <= 3 * 10⁴
The tree can have negative values
A single node has a consecutive sequence length of 1

Visualization

Tap to expand

Understanding the Visualization

Start at Leaf Checkpoints

Begin at leaf nodes (endpoints of trails) - each starts with path length 1

Extend Paths Upward

As you move up to parent checkpoints, extend consecutive paths based on number differences

Combine at Junction Points

At internal nodes, combine ascending and descending paths to create longer cross-mountain routes

Track Maximum Trail

Keep track of the longest consecutive trail found during the entire exploration

Key Takeaway

🎯 Key Insight: By tracking both increasing and decreasing consecutive paths at each node during a single DFS traversal, we can efficiently find the longest consecutive sequence that may span across different subtrees through parent nodes.

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 21

The optimal solution uses a single DFS traversal where each node tracks the longest increasing and decreasing consecutive paths from its children. At each node, we attempt to combine paths from different directions to form longer child-parent-child sequences, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Path Tracking (Optimal)	O(n)	O(h)	Single DFS traversal tracking increasing and decreasing paths at each node

DFS with Path Tracking (Optimal) — Algorithm Steps

Perform a single DFS traversal of the tree
At each node, calculate longest increasing path from children
At each node, calculate longest decreasing path from children
Combine increasing and decreasing paths when they meet at a node
Track the global maximum length found
Return the maximum length

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Leaf Nodes

Start with leaf nodes, each has inc_len=1, dec_len=1

Extend Paths Upward

As we move up, extend paths based on consecutive values

Combine at Internal Nodes

At each internal node, try combining increasing and decreasing paths

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct Result {
    int inc;
    int dec;
};

int maxLength = 1;

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 Result dfs(struct TreeNode* node) {
    struct Result result = {0, 0};
    if (!node) return result;
    
    struct Result left = dfs(node->left);
    struct Result right = dfs(node->right);
    
    int incLen = 1, decLen = 1;
    
    // Extend increasing sequence
    if (node->left && node->left->val == node->val + 1) {
        if (left.inc + 1 > incLen) incLen = left.inc + 1;
    }
    if (node->right && node->right->val == node->val + 1) {
        if (right.inc + 1 > incLen) incLen = right.inc + 1;
    }
    
    // Extend decreasing sequence
    if (node->left && node->left->val == node->val - 1) {
        if (left.dec + 1 > decLen) decLen = left.dec + 1;
    }
    if (node->right && node->right->val == node->val - 1) {
        if (right.dec + 1 > decLen) decLen = right.dec + 1;
    }
    
    // Update global maximum
    if (incLen > maxLength) maxLength = incLen;
    if (decLen > maxLength) maxLength = decLen;
    
    // Try combining paths
    int combinedLength = incLen + decLen - 1;
    if (combinedLength > maxLength) maxLength = combinedLength;
    
    result.inc = incLen;
    result.dec = decLen;
    return result;
}

int longestConsecutive(struct TreeNode* root) {
    if (!root) return 0;
    
    maxLength = 1;
    dfs(root);
    return maxLength;
}

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

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal visiting each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

34.2K Views

Medium-High Frequency

~25 min Avg. Time

1.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

DFS with Path Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler