Minimum Cost to Make All Characters Equal

Minimum Cost to Make All Characters Equal - Problem

You're given a binary string consisting of only '0's and '1's, and you need to make all characters in the string equal with the minimum possible cost.

You have two powerful operations at your disposal:

Left Operation: Choose any index i and flip all characters from the beginning (index 0) up to index i (inclusive). This costs i + 1
Right Operation: Choose any index i and flip all characters from index i to the end of the string. This costs n - i

When you "flip" a character, '0' becomes '1' and '1' becomes '0'.

Goal: Find the minimum cost to make all characters in the string identical (either all '0's or all '1's).

Example: For string "0011", you could flip from index 2 to end (cost 2) to get "0000", or use other combinations of operations.

Input & Output

example_1.py — Basic case

$ Input: s = "0011"

› Output: 2

💡 Note: We have one transition at position 1 (between s[1]='0' and s[2]='1'). We can choose left operation (cost 2) or right operation (cost 2). Both cost the same, so minimum cost is 2.

example_2.py — Multiple transitions

$ Input: s = "010101"

› Output: 9

💡 Note: Transitions at positions 0,1,2,3,4. Costs: min(1,5)=1, min(2,4)=2, min(3,3)=3, min(4,2)=2, min(5,1)=1. Total: 1+2+3+2+1=9.

example_3.py — Already uniform

$ Input: s = "0000"

› Output: 0

💡 Note: All characters are already the same, so no operations are needed. Cost is 0.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
Binary string only - no other characters allowed

Visualization

Tap to expand

Understanding the Visualization

Identify Problem Areas

Find where adjacent switches are in different positions - these are the 'problem boundaries'

Calculate Tool Costs

For each boundary, calculate the cost of using Left Lever vs Right Lever

Choose Cheaper Tool

Pick the less expensive tool for each boundary and sum up all costs

Key Takeaway

🎯 Key Insight: Focus on transitions (boundaries) between different characters, not individual characters. For each transition, greedily choose the cheaper operation.

Asked in

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

The optimal solution uses a greedy approach that focuses on fixing transitions (positions where adjacent characters differ). For each transition at position i, we choose the cheaper of two operations: left flip (cost i+1) or right flip (cost n-i). This gives us O(n) time complexity and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Sequences)	O(2^n)	O(n)	Try all possible sequences of operations to find minimum cost
Greedy (Fix Transitions)	O(n)	O(1)	Only fix positions where adjacent characters differ, choosing cheaper operation each time

Brute Force (Try All Sequences) — Algorithm Steps

Generate all possible operation sequences
For each sequence, simulate the operations
Track the minimum cost across all valid sequences
Return the minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Sequences

Create all possible combinations of left/right operations

Simulate Each

Apply operations and calculate cost

Track Minimum

Keep track of the lowest cost found

Code -

solution.c — C

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

long long simulate(char* s, int operations[][2], int opCount) {
    int n = strlen(s);
    char* current = malloc((n + 1) * sizeof(char));
    strcpy(current, s);
    long long cost = 0;
    
    for (int i = 0; i < opCount; i++) {
        if (operations[i][0] == 0) { // left
            cost += operations[i][1] + 1;
            for (int j = 0; j <= operations[i][1]; j++) {
                current[j] = current[j] == '0' ? '1' : '0';
            }
        } else { // right
            cost += n - operations[i][1];
            for (int j = operations[i][1]; j < n; j++) {
                current[j] = current[j] == '0' ? '1' : '0';
            }
        }
    }
    
    char first = current[0];
    for (int i = 0; i < n; i++) {
        if (current[i] != first) {
            free(current);
            return LLONG_MAX;
        }
    }
    
    free(current);
    return cost;
}

long long minimumCost(char* s) {
    int n = strlen(s);
    long long minCost = LLONG_MAX;
    
    // Try different operation sequences (simplified)
    int maxMask = 1 << (2 * (n < 10 ? n : 10));
    for (int mask = 1; mask < maxMask; mask++) {
        int operations[20][2];
        int opCount = 0;
        int tempMask = mask;
        
        for (int i = 0; i < (n < 10 ? n : 10); i++) {
            if (tempMask & 1) {
                operations[opCount][0] = 0;
                operations[opCount][1] = i;
                opCount++;
            }
            tempMask >>= 1;
            if (tempMask & 1) {
                operations[opCount][0] = 1;
                operations[opCount][1] = i;
                opCount++;
            }
            tempMask >>= 1;
        }
        
        if (opCount > 0) {
            long long cost = simulate(s, operations, opCount);
            if (cost < minCost) {
                minCost = cost;
            }
        }
    }
    
    return minCost == LLONG_MAX ? 0 : minCost;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We potentially try all possible combinations of operations, leading to exponential complexity

⚠ Quadratic Growth

Space Complexity

O(n)

Need space to store the current state of the string during simulation

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~18 min Avg. Time

856 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 Sequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler