Minimum Swaps to Group All 1's Together II

Minimum Swaps to Group All 1's Together II - Problem

You are given a binary circular array where the first and last elements are considered adjacent. Your goal is to find the minimum number of swaps needed to group all the 1s together in any contiguous segment of the array.

A swap operation exchanges the values at two distinct positions in the array. Since the array is circular, you can think of it as arranged in a circle where position 0 comes right after the last position.

Example: In array [0,1,0,1,1,0,0], we can group all three 1s together by making just 1 swap. We could swap positions to get [0,0,1,1,1,0,0] where all 1s are grouped together.

Your task: Return the minimum number of swaps required to achieve this grouping at any location in the circular array.

Input & Output

example_1.py — Basic case

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

› Output: 1

💡 Note: We need to group 3 ones together. The optimal window contains positions [3,4,5] which has 2 ones and 1 zero. So we need 1 swap to replace the zero with a one from elsewhere.

example_2.py — Circular wrapping

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

› Output: 2

💡 Note: We have 5 ones total. The best window wraps around: positions [6,7,0,1,2] contains 4 ones and 1 zero. We need 1 swap. Actually, let me recalculate: positions [1,2,3,4,5] has 3 ones and 2 zeros, so we need 2 swaps.

example_3.py — All ones

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

› Output: 0

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

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
The array is treated as circular

Visualization

Tap to expand

Understanding the Visualization

Count Total Occupied

First, count how many seats are occupied - this tells us our target window size

Find Best Window

Look for a contiguous section of that size which already has the most occupied seats

Calculate Swaps

The number of swaps needed equals total occupied minus the maximum occupied found in any window

Handle Circular

Since it's circular, the optimal grouping might wrap around from end to beginning

Key Takeaway

🎯 Key Insight: Use sliding window to find the position where we already have the most 1s grouped together. The minimum swaps needed equals total 1s minus the maximum 1s found in any window of optimal size.

Asked in

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

The optimal solution uses a sliding window technique with O(n) time complexity. Key insight: find the window of size equal to total 1s count that contains the maximum number of 1s. The answer is total_ones - max_ones_in_any_window. Handle the circular array by either using modular arithmetic or doubling the array.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Positions)	O(n²)	O(1)	Try every possible starting position for grouping all 1s and calculate swaps needed
Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to efficiently find the best position for grouping 1s

Brute Force (Check All Positions) — Algorithm Steps

Count total number of 1s in the array
For each possible starting position i (0 to n-1):
Consider a window of size equal to total 1s count starting from position i
Handle circular wraparound when window extends beyond array end
Count how many 0s are in this window - this equals swaps needed
Keep track of minimum swaps across all positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Total 1s

First count how many 1s need to be grouped together

Try Each Position

For each starting position, examine a window of size equal to total 1s

Count Zeros

Count zeros in current window - these need to be swapped out

Track Minimum

Keep track of the minimum zeros found across all windows

Code -

solution.c — C

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

int minSwaps(int* nums, int n) {
    int totalOnes = 0;
    for (int i = 0; i < n; i++) {
        totalOnes += nums[i];
    }
    
    if (totalOnes <= 1) return 0;
    
    int minSwaps = n;
    
    // Try each starting position
    for (int start = 0; start < n; start++) {
        int zerosInWindow = 0;
        
        // Count zeros in window of size totalOnes
        for (int i = 0; i < totalOnes; i++) {
            int pos = (start + i) % n;
            if (nums[pos] == 0) {
                zerosInWindow++;
            }
        }
        
        if (zerosInWindow < minSwaps) {
            minSwaps = zerosInWindow;
        }
    }
    
    return minSwaps;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int n = 0;
    
    // Parse input
    for (int i = 0; line[i]; i++) {
        if (line[i] >= '0' && line[i] <= '9') {
            nums[n++] = line[i] - '0';
        }
    }
    
    printf("%d\n", minSwaps(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n starting positions, we examine a window of size up to n elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track counts and minimum

✓ Linear Space

42.3K Views

Medium-High Frequency

~15 min Avg. Time

1.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

Brute Force (Check All Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler