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.

Visualization

Tap to expand

Understanding the Visualization

Identify Structure

Map out the boolean operations tree with leaves as switches

Calculate Leaf Costs

For each switch, determine flip cost for true/false

Combine Gate Costs

Work upward, calculating optimal costs for each gate

Find Optimal Path

Choose the minimum cost path to desired output

Key Takeaway

🎯 Key Insight: By calculating costs for both true and false outcomes at each node, we can optimally combine paths and avoid exploring all exponential possibilities, reducing complexity from O(2^n) to O(n).

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal of tree with constant work per node

✓ Linear Growth

Space Complexity

O(h)

Recursion stack proportional to tree height

✓ Linear Space

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

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

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(h)	Calculate minimum flips for both true and false at each node
Brute Force (Try All Combinations)	O(2^n × h)	O(h)	Try all possible combinations of leaf flips and find minimum

Dynamic Programming (Optimal) — Algorithm Steps

For each node, compute cost to make it true and false
For leaf nodes: cost[true] = 1-val, cost[false] = val
For internal nodes: compute based on operation type
Return the cost for root to achieve desired result

Visualization

Tap to expand

Step-by-Step Walkthrough

Leaf Nodes

Base case: cost to flip leaf to desired value

Internal Nodes

Calculate costs based on operation type

Propagate Up

Combine children costs optimally

Root Result

Return cost for desired result at root

Code -

solution.c — C

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

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

struct Costs {
    int costTrue;
    int costFalse;
};

struct Costs dfs(struct TreeNode* node) {
    struct Costs result = {INT_MAX, INT_MAX};
    if (!node) return result;
    
    // Leaf node
    if (!node->left && !node->right) {
        if (node->val == 0) {
            result.costTrue = 1;
            result.costFalse = 0;
        } else {
            result.costTrue = 0;
            result.costFalse = 1;
        }
        return result;
    }
    
    // NOT operation
    if (node->val == 5) {
        struct TreeNode* child = node->left ? node->left : node->right;
        struct Costs childCosts = dfs(child);
        result.costTrue = childCosts.costFalse;
        result.costFalse = childCosts.costTrue;
        return result;
    }
    
    // Binary operations
    struct Costs leftCosts = dfs(node->left);
    struct Costs rightCosts = dfs(node->right);
    
    if (node->val == 2) { // OR
        int opt1 = leftCosts.costTrue + rightCosts.costFalse;
        int opt2 = leftCosts.costFalse + rightCosts.costTrue;
        int opt3 = leftCosts.costTrue + rightCosts.costTrue;
        result.costTrue = (opt1 < opt2) ? ((opt1 < opt3) ? opt1 : opt3) : ((opt2 < opt3) ? opt2 : opt3);
        result.costFalse = leftCosts.costFalse + rightCosts.costFalse;
    } else if (node->val == 3) { // AND
        result.costTrue = leftCosts.costTrue + rightCosts.costTrue;
        int opt1 = leftCosts.costFalse + rightCosts.costTrue;
        int opt2 = leftCosts.costTrue + rightCosts.costFalse;
        int opt3 = leftCosts.costFalse + rightCosts.costFalse;
        result.costFalse = (opt1 < opt2) ? ((opt1 < opt3) ? opt1 : opt3) : ((opt2 < opt3) ? opt2 : opt3);
    } else { // XOR
        int opt1 = leftCosts.costTrue + rightCosts.costFalse;
        int opt2 = leftCosts.costFalse + rightCosts.costTrue;
        result.costTrue = (opt1 < opt2) ? opt1 : opt2;
        
        opt1 = leftCosts.costTrue + rightCosts.costTrue;
        opt2 = leftCosts.costFalse + rightCosts.costFalse;
        result.costFalse = (opt1 < opt2) ? opt1 : opt2;
    }
    
    return result;
}

int minimumFlips(struct TreeNode* root, bool result) {
    struct Costs costs = dfs(root);
    return result ? costs.costTrue : costs.costFalse;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal of tree with constant work per node

✓ Linear Growth

Space Complexity

O(h)

Recursion stack proportional to tree height

✓ Linear Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler