Flip String to Monotone Increasing

Flip String to Monotone Increasing - Problem

A binary string is monotone increasing if it consists of some number of 0's (possibly none), followed by some number of 1's (also possibly none).

You are given a binary string s. You can flip s[i] changing it from 0 to 1 or from 1 to 0.

Return the minimum number of flips to make s monotone increasing.

Input & Output

Example 1 — Basic Case

$ Input: s = "10011"

› Output: 1

💡 Note: We can flip s[1] = '0' to get "11011", then flip s[2] = '0' to get "11111". Total: 2 flips. Or we can flip s[0] = '1' to get "00011" which is monotone increasing. Total: 1 flip (optimal).

Example 2 — Already Monotone

$ Input: s = "00111"

› Output: 0

💡 Note: String is already monotone increasing (0s followed by 1s), so no flips needed.

Example 3 — All Same Characters

$ Input: s = "1111"

› Output: 0

💡 Note: All 1s is monotone increasing, so no flips needed.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is that at each position with a '0', we have two choices: flip it to '1' or flip all previous '1's to '0's. The optimal approach uses dynamic programming to track the minimum flips needed, making the best choice at each step. Time: O(n), Space: O(1)

Common Approaches

✓ Dynamic Programming (Optimal)

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

Use dynamic programming to track the minimum flips needed. At each position, decide whether to keep building a monotone sequence or start fresh by making everything seen so far into 0s.

Prefix Sum Optimization

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

Instead of recounting for each split, precompute prefix sums of 1s and 0s. For any split position, we can calculate the cost instantly using these prefix sums.

Try All Split Points

⏱️ Time: O(n²) Space: O(1)

For each possible split point, calculate the cost of making all characters before it 0s and all characters after it 1s. The split can be before the string, after the string, or between any two characters.

Dynamic Programming (Optimal) — Algorithm Steps

Step 1: Track count of 1s seen so far
Step 2: For each 0, decide: flip it to 1, or flip all previous 1s to 0
Step 3: Choose the option with minimum cost

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 1s

Count 1s seen so far

Process 0s

Choose: flip 0→1 or flip previous 1s→0

Optimal choice

Take minimum cost option

Code -

solution.c — C

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

int solution(char* s) {
    int ones = 0; // Count of 1s seen so far
    int flips = 0; // Minimum flips needed so far
    
    for (int i = 0; s[i]; i++) {
        if (s[i] == '1') {
            ones++;
        } else { // s[i] == '0'
            // Two choices:
            // 1. Flip this 0 to 1: flips + 1
            // 2. Flip all previous 1s to 0: ones
            int choice1 = flips + 1;
            int choice2 = ones;
            flips = choice1 < choice2 ? choice1 : choice2;
        }
    }
    
    return flips;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // Remove newline
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant work per character

✓ Linear Growth

Space Complexity

O(1)

Only uses two variables to track state

✓ Linear Space

87.0K Views

Medium Frequency

~25 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler