Correct a Binary Tree

Correct a Binary Tree - Problem

Correct a Binary Tree

You're given a binary tree that has been corrupted! 🔧 There's exactly one defective node where its right child incorrectly points to another node at the same depth, but further to the right (instead of pointing to its actual right child or null).

Your mission is to detect and remove this corrupted node along with its entire subtree, then return the corrected binary tree.

Key Points:
• The invalid node's right pointer goes to a node at the same level
• The target node is to the right of the invalid node
• Remove the invalid node and everything below it
• Keep the incorrectly pointed-to node (it's innocent!)

Example: If node 2's right child incorrectly points to node 5 (instead of node 3), remove node 2 and its subtree, but keep node 5 in its correct position.

Input & Output

example_1.py — Basic Invalid Node

$ Input: root = [1,2,3,4,null,null,null], fromNode = 2, toNode = 3

› Output: [1,null,3]

💡 Note: Node 2's right child incorrectly points to node 3 (which should be at the same level). After removing node 2 and its subtree (including node 4), we get the corrected tree with root 1 having only a right child 3.

example_2.py — Deeper Tree

$ Input: root = [1,2,3,4,5,6,7], fromNode = 4, toNode = 5

› Output: [1,null,3,null,null,6,7]

💡 Note: Node 4 incorrectly points to node 5. After removing node 4 (and any children it might have had), node 2 becomes a leaf, and the tree structure is preserved correctly.

example_3.py — Root is Invalid

$ Input: root = [1,2], fromNode = 1, toNode = 2

› Output: null

💡 Note: The root node itself is invalid (pointing to its own child incorrectly). Since we remove the invalid node, the entire tree is removed, resulting in null.

Constraints

The number of nodes in the tree is in the range [2, 10⁴]
1 ≤ Node.val ≤ 10⁴
There is exactly one invalid node
The invalid node's right child points to another node at the same depth
The pointed-to node is to the right of the invalid node

Visualization

Tap to expand

Asked in

f Meta 25 G Google 20 a Amazon 15 ⊞ Microsoft 10

The optimal approach uses right-to-left BFS traversal with a hash set. Since invalid nodes point to nodes on their RIGHT at the same level, processing each level from right-to-left allows us to detect invalid forward references immediately when we encounter a node whose right child is already in our 'seen' set. This achieves O(n) time complexity with O(w) space where w is the maximum width of the tree.

Common Approaches

✓ Memoization

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

Brute Force (Level-Order Validation)

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

Perform level-order traversal and for each level, check if any node's right child points to another node at the same level. This involves comparing each node with all other nodes at the same depth.

Right-to-Left BFS with Set (Optimal)

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

The key insight is that invalid nodes point to nodes further RIGHT. By traversing each level from RIGHT to LEFT and keeping track of seen nodes, we can immediately detect when a node points to a 'future' node we've already seen.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

bool isBeautiful(int num) {
    if (num == 1) {
        return true;
    }
    
    // Check if number contains 0 (making product 0)
    int digits[20];
    int count = 0;
    int temp = num;
    while (temp > 0) {
        digits[count++] = temp % 10;
        temp /= 10;
    }
    
    for (int i = 0; i < count; i++) {
        if (digits[i] == 0) {
            return true;
        }
    }
    
    // For other numbers, check if product % sum == 0
    int product = 1;
    int digitSum = 0;
    for (int i = 0; i < count; i++) {
        product *= digits[i];
        digitSum += digits[i];
    }
    
    return digitSum > 0 && product % digitSum == 0;
}

int solution(int l, int r) {
    int count = 0;
    for (int num = l; num <= r; num++) {
        if (isBeautiful(num)) {
            count++;
        }
    }
    return count;
}

int main() {
    int l, r;
    scanf("%d", &l);
    scanf("%d", &r);
    
    int result = solution(l, r);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

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