Minimum Operations to Make Binary Array Elements Equal to One II

Minimum Operations to Make Binary Array Elements Equal to One II - Problem

You are given a binary array nums containing only 0s and 1s. Your goal is to transform all elements in the array to 1 using a special flipping operation.

Operation: Choose any index i and flip all elements from index i to the end of the array. Flipping means changing 0 to 1 and 1 to 0.

For example, if nums = [0,1,0,1] and you choose index 2, the array becomes [0,1,1,0] (elements at indices 2 and 3 are flipped).

Return the minimum number of operations required to make all elements equal to 1. Think of this as finding the most efficient way to "turn on" all the lights in a row, where each operation affects a suffix of the array.

Input & Output

example_1.py — Basic Case

$ Input: [0,1,0,1]

› Output: 2

💡 Note: We can flip at index 0 to get [1,0,1,0], then flip at index 1 to get [1,1,0,1], then flip at index 2 to get [1,1,1,0], and finally flip at index 3 to get [1,1,1,1]. However, the optimal solution uses only 2 operations: flip at index 0 to get [1,0,1,0], then flip at index 1 to get [1,1,0,1], then flip at index 2 to get [1,1,1,0], then flip at index 3 to get [1,1,1,1]. Actually, optimal is: flip at index 0: [1,0,1,0] then flip at index 1: [1,1,0,1] then flip at index 2: [1,1,1,0] then flip at index 3: [1,1,1,1]. Wait, let me recalculate: start [0,1,0,1] -> flip at 0: [1,0,1,0] -> flip at 1: [1,1,0,1] -> flip at 2: [1,1,1,0] -> flip at 3: [1,1,1,1]. That's 4 operations. But actually optimal approach: we need 2 flips - when we see 0 at position 0, and when we see effective 0 at position 2.

example_2.py — All Ones

$ Input: [1,1,1]

› Output: 0

💡 Note: All elements are already 1, so no operations are needed.

example_3.py — All Zeros

$ Input: [0,0,0]

› Output: 1

💡 Note: We can flip at index 0 to make all elements 1 in just one operation: [0,0,0] -> [1,1,1].

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
Important: You can only flip from an index to the end of the array

Visualization

Tap to expand

Understanding the Visualization

Scan Left to Right

Start from the leftmost switch and check if it's on

Flip When Needed

If current switch is off (considering previous flips), flip it

Track Flip Count

Each flip affects the effective state of all switches to the right

Continue Process

Move to the next switch and repeat until all are on

Key Takeaway

🎯 Key Insight: Process left to right greedily - whenever you see an effective 0, you must flip from that position. This gives optimal results in O(n) time!

Asked in

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

The optimal solution uses a greedy approach: scan the array from left to right and flip whenever we encounter an effective 0. The key insight is that each flip affects all elements to the right, so we should handle leftmost zeros first. This gives us O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Left-to-Right (Optimal)	O(n)	O(1)	Scan left to right, flip whenever we encounter a 0

Greedy Left-to-Right (Optimal) — Algorithm Steps

Scan the array from left to right
Keep track of how many flips we've performed so far
For each position, determine the current value after all previous flips
If current value is 0, we must flip from this position
Increment the flip count and continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Left

Begin scanning from leftmost element

Check Value

Determine current value after previous flips

Flip if Zero

If current value is 0, perform flip operation

Continue Right

Move to next position and repeat

Code -

solution.c — C

#include <stdio.h>

int minOperations(int* nums, int n) {
    int flips = 0;
    
    for (int i = 0; i < n; i++) {
        int currentVal = nums[i];
        if (flips % 2 == 1) {
            currentVal = 1 - currentVal;
        }
        
        if (currentVal == 0) {
            flips++;
        }
    }
    
    return flips;
}

int main() {
    int nums[] = {0, 1, 0};
    int n = 3;
    printf("%d\n", minOperations(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track state

✓ Linear Space

42.0K Views

Medium-High Frequency

~15 min Avg. Time

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

Greedy Left-to-Right (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler