Flip String to Monotone Increasing - Practice Coding Problems

Flip String to Monotone Increasing - Problem

Imagine you have a binary string that needs to be organized like a perfect gradient - all the 0s should come first, followed by all the 1s. This is what we call a monotone increasing binary string.

You're given a binary string s containing only '0' and '1' characters. You can flip any character (change '0' to '1' or '1' to '0'), but each flip costs you one operation.

Goal: Find the minimum number of flips needed to make the string monotone increasing.

Examples:

"00110" → "00011" (1 flip: change middle '1' to '0')
"10" → "01" (1 flip: either flip first or second character)
"0101" → "0011" (1 flip: change second '1' to '0')

Input & Output

example_1.py — Basic case

$ Input: s = "00110"

› Output: 1

💡 Note: We can flip the middle '1' at index 2 to '0' to get "00010", then it becomes monotone increasing. Only 1 flip needed.

example_2.py — Two choices

$ Input: s = "10"

› Output: 1

💡 Note: Either flip the first character to get "00" or flip the second character to get "11". Both require 1 flip.

example_3.py — Multiple options

$ Input: s = "0101"

› Output: 1

💡 Note: We can flip the '1' at index 1 to get "0001" (monotone increasing with 1 flip) or flip the '0' at index 2 to get "0111" (also 1 flip).

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
The string is non-empty

Visualization

Tap to expand

Understanding the Visualization

Scan the Shelf

Go through books left to right, keeping track of hardcovers seen

Decision at Each Paperback

When you find a paperback after hardcovers, decide: change this paperback to hardcover, or change all previous hardcovers to paperbacks

Greedy Choice

Always choose the option requiring fewer changes - this greedy choice is provably optimal

Final Result

The running minimum gives you the optimal solution

Key Takeaway

🎯 Key Insight: At each position containing '0' after seeing some '1's, we face a choice: flip this '0' or flip all previous '1's. The greedy strategy of always choosing the cheaper option leads to the globally optimal solution.

Asked in

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

The optimal solution uses dynamic programming in a single pass. At each '0' character, we choose the minimum between flipping it to '1' or flipping all previously seen '1's to '0's. This greedy approach ensures we always make the locally optimal choice, which leads to the globally optimal solution. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Optimization	O(n)	O(n)	Precompute prefix sums to avoid recalculating counts
Brute Force (Try All Split Points)	O(n²)	O(1)	Try every possible split point between 0s and 1s sections
One-Pass Dynamic Programming (Optimal)	O(n)	O(1)	Track minimum flips using DP while scanning left to right

Two-Pass Optimization — Algorithm Steps

First pass: create prefix sum array counting 1s from left
Second pass: create suffix sum array counting 0s from right
For each split point, use precomputed sums to get flip count
Return minimum across all split points

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Array

Count 1s from left at each position

Build Suffix Array

Count 0s from right at each position

Calculate Costs

For each split: prefix[i] + suffix[i]

Find Minimum

Return the minimum cost across all splits

Code -

solution.c — C

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

int minFlipsMonoIncr(char* s) {
    int n = strlen(s);
    
    // Prefix sum of 1s
    int* prefixOnes = (int*)calloc(n + 1, sizeof(int));
    for (int i = 0; i < n; i++) {
        prefixOnes[i + 1] = prefixOnes[i] + (s[i] == '1' ? 1 : 0);
    }
    
    // Suffix sum of 0s
    int* suffixZeros = (int*)calloc(n + 1, sizeof(int));
    for (int i = n - 1; i >= 0; i--) {
        suffixZeros[i] = suffixZeros[i + 1] + (s[i] == '0' ? 1 : 0);
    }
    
    int minFlips = INT_MAX;
    
    // Try all split points
    for (int i = 0; i <= n; i++) {
        int flips = prefixOnes[i] + suffixZeros[i];
        if (flips < minFlips) {
            minFlips = flips;
        }
    }
    
    free(prefixOnes);
    free(suffixZeros);
    return minFlips;
}

int main() {
    char s[100001];
    scanf("%s", s);
    if (s[0] == '"') {
        int len = strlen(s);
        for (int i = 0; i < len - 2; i++) {
            s[i] = s[i + 1];
        }
        s[len - 2] = '\0';
    }
    printf("%d\n", minFlipsMonoIncr(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the string plus one pass to check all splits

✓ Linear Growth

Space Complexity

O(n)

Two arrays to store prefix and suffix sums

⚡ Linearithmic Space

67.5K Views

Medium-High Frequency

~18 min Avg. Time

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

Two-Pass Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler