Minimum Flips in Binary Tree to Get Result

Minimum Flips in Binary Tree to Get Result - Problem

Imagine you have a binary expression tree where each leaf contains a boolean value (0 for false, 1 for true) and each internal node represents a boolean operation:

2 = OR operation
3 = AND operation
4 = XOR operation
5 = NOT operation (has only one child)

Your goal is to find the minimum number of leaf flips needed to make the entire tree evaluate to a desired result. A flip changes 0→1 or 1→0.

Key Challenge: You need to work backwards from the root, determining what each subtree should evaluate to in order to achieve the target result with minimum flips.

Input & Output

example_1.py — Basic OR Operation

$ Input: root = [2,0,1], result = false Tree: OR(0,1)

› Output: 1

💡 Note: The tree evaluates to true (0 OR 1 = true). To get false, we need both children false, so flip the right child: 1 flip needed.

example_2.py — AND with XOR

$ Input: root = [3,4,[0,1],1], result = true Tree: AND(XOR(0,1),1)

› Output: 0

💡 Note: XOR(0,1) = true, AND(true,1) = true. Already evaluates to true, so 0 flips needed.

example_3.py — NOT Operation

$ Input: root = [5,0], result = true Tree: NOT(0)

› Output: 0

💡 Note: NOT(0) = true. Already evaluates to the desired result, so 0 flips needed.

Constraints

The number of nodes in the tree is in the range [1, 10⁵]
Node values: 0, 1 for leaves, 2, 3, 4, 5 for internal nodes
NOT nodes have exactly one child, others have exactly two children
Leaf nodes have values 0 or 1 only
It is guaranteed that result can always be achieved

Visualization

Tap to expand

Asked in

G Google 45 ⊞ Microsoft 32 f Meta 28 a Amazon 24

The optimal solution uses dynamic programming to calculate the minimum flips needed to make each subtree evaluate to both true and false. For each node, we compute costs based on its operation type and combine children's costs optimally. This achieves O(n) time complexity by avoiding redundant calculations, making it far superior to the exponential brute force approach.

Common Approaches

✓ Brute Force (Try All Combinations)

⏱️ Time: O(2^n × h) Space: O(h)

Generate all possible combinations of leaf node values, evaluate each combination, and return the minimum flips needed among valid combinations.

Dynamic Programming (Optimal)

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

Use dynamic programming to compute the minimum flips needed to make each subtree evaluate to both true and false. For each node, determine the optimal way to achieve the desired result based on its operation and children's costs.

Brute Force (Try All Combinations) — Algorithm Steps

Collect all leaf nodes in the tree
Generate all 2^n possible combinations of leaf values
For each combination, evaluate the tree from bottom up
Count flips needed and track minimum among valid results

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Leaves

Gather all leaf nodes from the tree

Generate Combinations

Create all 2^n possible leaf value combinations

Evaluate Each

Test each combination and count required flips

Find Minimum

Return the minimum flips among valid results

Code -

solution.c — C

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

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

void collectLeaves(struct TreeNode* node, struct TreeNode** leaves, int* count) {
    if (!node) return;
    if (!node->left && !node->right) {
        leaves[(*count)++] = node;
    } else {
        collectLeaves(node->left, leaves, count);
        collectLeaves(node->right, leaves, count);
    }
}

bool evaluate(struct TreeNode* node) {
    if (!node->left && !node->right) {
        return node->val == 1;
    }
    
    switch (node->val) {
        case 2: // OR
            return evaluate(node->left) || evaluate(node->right);
        case 3: // AND
            return evaluate(node->left) && evaluate(node->right);
        case 4: // XOR
            return evaluate(node->left) != evaluate(node->right);
        case 5: // NOT
            {
                struct TreeNode* child = node->left ? node->left : node->right;
                return !evaluate(child);
            }
    }
    return false;
}

int minimumFlips(struct TreeNode* root, bool result) {
    struct TreeNode* leaves[1000];
    int leafCount = 0;
    collectLeaves(root, leaves, &leafCount);
    
    int minFlips = INT_MAX;
    
    // Try all 2^n combinations
    for (int mask = 0; mask < (1 << leafCount); mask++) {
        int originalVals[1000];
        int flips = 0;
        
        for (int i = 0; i < leafCount; i++) {
            originalVals[i] = leaves[i]->val;
            int newVal = (mask >> i) & 1;
            if (newVal != leaves[i]->val) flips++;
            leaves[i]->val = newVal;
        }
        
        if (evaluate(root) == result) {
            if (flips < minFlips) {
                minFlips = flips;
            }
        }
        
        // Restore original values
        for (int i = 0; i < leafCount; i++) {
            leaves[i]->val = originalVals[i];
        }
    }
    
    return minFlips;
}

struct TreeNode* buildTree(int* arr, int size) {
    if (size == 0 || arr[0] == -1) return NULL;
    
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = arr[0];
    root->left = NULL;
    root->right = NULL;
    
    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] != -1) {
            node->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            node->left->val = arr[i];
            node->left->left = NULL;
            node->left->right = NULL;
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && arr[i] != -1) {
            node->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
            node->right->val = arr[i];
            node->right->left = NULL;
            node->right->right = NULL;
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int parseArray(char* s, int* arr) {
    int len = strlen(s);
    if (len == 0) return 0;
    
    int count = 0;
    int i = 0;
    
    // Skip initial bracket if present
    if (s[0] == '[') i = 1;
    
    while (i < len) {
        // Skip whitespace and commas
        while (i < len && (s[i] == ' ' || s[i] == ',')) i++;
        if (i >= len) break;
        
        // Stop at closing bracket
        if (s[i] == ']') break;
        
        // Handle null values
        if (s[i] == 'n') {
            arr[count++] = -1;
            while (i < len && s[i] != ',' && s[i] != ']') i++;
        } else if (s[i] >= '0' && s[i] <= '9') {
            // Parse number
            int num = 0;
            while (i < len && s[i] >= '0' && s[i] <= '9') {
                num = num * 10 + (s[i] - '0');
                i++;
            }
            arr[count++] = num;
        } else {
            i++; // Skip unknown characters
        }
    }
    
    return count;
}

int main() {
    char rootStr[1000];
    char resultStr[10];
    
    fgets(rootStr, sizeof(rootStr), stdin);
    fgets(resultStr, sizeof(resultStr), stdin);
    
    // Remove newline
    rootStr[strcspn(rootStr, "\n")] = 0;
    resultStr[strcspn(resultStr, "\n")] = 0;
    
    int arr[1000];
    int size = parseArray(rootStr, arr);
    
    struct TreeNode* root = buildTree(arr, size);
    bool result = strcmp(resultStr, "true") == 0;
    
    int answer = minimumFlips(root, result);
    printf("%d\n", answer);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × h)

2^n combinations where n is leaf count, h is height for evaluation

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack for tree evaluation

✓ Linear Space

36.7K Views

Medium 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler