Minimum Cost to Change the Final Value of Expression

Minimum Cost to Change the Final Value of Expression - Problem

Minimum Cost to Change the Final Value of Expression

You are given a valid boolean expression as a string consisting of:
• '1' and '0' (boolean values)
• '&' (bitwise AND operator)
• '|' (bitwise OR operator)
• '(' and ')' (parentheses for grouping)

Important: Unlike typical boolean expressions, operators have equal precedence and are evaluated left-to-right (after handling parentheses).

Your goal is to find the minimum number of operations needed to flip the final result of the expression. You can perform these operations:
1. Turn '1' → '0' or '0' → '1'
2. Turn '&' → '|' or '|' → '&'

Example: If expression = "1|1|(0&0)&1"
• Current evaluation: 1|1|0&1 = 1|0&1 = 1&1 = 1
• We want to change it to evaluate to 0
• Return the minimum cost to achieve this flip

Input & Output

example_1.py — Simple OR Expression

$ Input: expression = "1|1|(0&0)&1"

› Output: 1

💡 Note: The expression evaluates as: 1|1|0&1 = 1|0&1 = 1&1 = 1. To make it evaluate to 0, we can change the last '1' to '0': "1|1|(0&0)&0" → 1|1|0&0 = 1|0&0 = 1&0 = 0. Cost: 1 operation.

example_2.py — Parentheses Expression

$ Input: expression = "(0&0)&1"

› Output: 1

💡 Note: The expression evaluates as: (0&0)&1 = 0&1 = 0. To make it evaluate to 1, we can change the '&' to '|': "(0&0)|1" → 0|1 = 1. Cost: 1 operation.

example_3.py — Single Digit

$ Input: expression = "0"

› Output: 1

💡 Note: The expression evaluates to 0. To make it evaluate to 1, we need to change '0' to '1'. Cost: 1 operation.

Constraints

1 ≤ expression.length ≤ 10⁵
expression consists of '1', '0', '&', '|', '(', and ')'
All parentheses are properly matched
The given expression is guaranteed to be valid
No operator precedence - evaluate left-to-right after parentheses

Asked in

This problem requires dynamic programming with expression parsing. The optimal approach uses recursive descent parsing to handle operator precedence correctly, computing the minimum cost to achieve both possible outcomes (0 and 1) at each subexpression. The key insight is that we need to track both costs simultaneously and combine them appropriately for each operator type.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(n)	O(n)	Use recursive DP to compute minimum costs for both 0 and 1 results at each subexpression

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Parse expression using recursive descent with operator precedence
For each subexpression, compute minimum cost to achieve both 0 and 1
Use memoization to avoid recomputing same subexpressions
For operators, combine costs from left and right subexpressions
Return the cost to flip from current result to opposite

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Atoms

For each '0' or '1', compute cost to make it 0 or 1

Combine with Operators

For each operator, combine costs from left and right subexpressions

Propagate Upward

Each level computes minimum costs for both possible outcomes

Return Answer

Root contains costs for both outcomes, return cost to flip current result

Code -

solution.c — C

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

typedef struct {
    int cost_for_0;
    int cost_for_1;
} CostPair;

static int index_global;
static char* expr_global;

CostPair parseAtom();
CostPair parseAnd();
CostPair parseOr();
int evaluate(char* expr, int len);
int min(int a, int b);
int min4(int a, int b, int c, int d);

int minOperationsToFlip(char* expression) {
    expr_global = expression;
    index_global = 0;
    
    CostPair costs = parseOr();
    int currentResult = evaluate(expression, strlen(expression));
    
    return currentResult == 0 ? costs.cost_for_1 : costs.cost_for_0;
}

CostPair parseAtom() {
    CostPair result;
    
    if (expr_global[index_global] == '(') {
        index_global++; // skip '('
        result = parseOr();
        index_global++; // skip ')'
        return result;
    } else {
        int digit = expr_global[index_global] - '0';
        index_global++;
        
        if (digit == 0) {
            result.cost_for_0 = 0;
            result.cost_for_1 = 1;
        } else {
            result.cost_for_0 = 1;
            result.cost_for_1 = 0;
        }
        return result;
    }
}

CostPair parseAnd() {
    CostPair left = parseAtom();
    
    while (index_global < strlen(expr_global) && expr_global[index_global] == '&') {
        index_global++; // skip '&'
        CostPair right = parseAtom();
        
        int costToMake0 = min4(
            left.cost_for_0 + right.cost_for_0,
            left.cost_for_0 + right.cost_for_1,
            left.cost_for_1 + right.cost_for_0,
            1 + left.cost_for_1 + right.cost_for_1
        );
        int costToMake1 = left.cost_for_1 + right.cost_for_1;
        
        left.cost_for_0 = costToMake0;
        left.cost_for_1 = costToMake1;
    }
    
    return left;
}

CostPair parseOr() {
    CostPair left = parseAnd();
    
    while (index_global < strlen(expr_global) && expr_global[index_global] == '|') {
        index_global++; // skip '|'
        CostPair right = parseAnd();
        
        int costToMake0 = left.cost_for_0 + right.cost_for_0;
        int costToMake1 = min4(
            left.cost_for_1 + right.cost_for_0,
            left.cost_for_0 + right.cost_for_1,
            left.cost_for_1 + right.cost_for_1,
            1 + left.cost_for_0 + right.cost_for_0
        );
        
        left.cost_for_0 = costToMake0;
        left.cost_for_1 = costToMake1;
    }
    
    return left;
}

int evaluate(char* expr, int len) {
    int stack[1000];
    int top = -1;
    int i = 0;
    
    while (i < len) {
        char c = expr[i];
        if (c == '0' || c == '1') {
            stack[++top] = c - '0';
        } else if (c == '(') {
            int count = 1, j = i + 1;
            while (count > 0 && j < len) {
                if (expr[j] == '(') count++;
                else if (expr[j] == ')') count--;
                j++;
            }
            char temp = expr[j-1];
            expr[j-1] = '\0';
            int result = evaluate(expr + i + 1, j - i - 2);
            expr[j-1] = temp;
            stack[++top] = result;
            i = j - 1;
        } else if ((c == '&' || c == '|') && top >= 0) {
            char op = c;
            i++;
            int nextVal;
            
            if (i < len && (expr[i] == '0' || expr[i] == '1')) {
                nextVal = expr[i] - '0';
            } else if (i < len && expr[i] == '(') {
                int count = 1, j = i + 1;
                while (count > 0 && j < len) {
                    if (expr[j] == '(') count++;
                    else if (expr[j] == ')') count--;
                    j++;
                }
                char temp = expr[j-1];
                expr[j-1] = '\0';
                nextVal = evaluate(expr + i + 1, j - i - 2);
                expr[j-1] = temp;
                i = j - 1;
            } else {
                i++;
                continue;
            }
            
            int prevVal = stack[top--];
            if (op == '&') {
                stack[++top] = prevVal & nextVal;
            } else {
                stack[++top] = prevVal | nextVal;
            }
        }
        i++;
    }
    return top >= 0 ? stack[top] : 0;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int min4(int a, int b, int c, int d) {
    return min(min(a, b), min(c, d));
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character in expression is processed exactly once

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and memoization storage

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Related Problems

Common Approaches

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler