Minimum Moves to Pick K Ones

Minimum Moves to Pick K Ones - Problem

You're given a binary array nums of length n, and two integers: k (the number of ones to collect) and maxChanges (maximum flips allowed).

Alice's Mission: Collect exactly k ones using the minimum number of moves possible!

Game Rules:

Alice starts at any index aliceIndex she chooses
If there's a 1 at her starting position, she picks it up for free (no move cost)
She can perform two types of moves:
- Create a 1: Change any 0 to 1 (costs 1 move, limited to maxChanges times)
- Swap adjacent: Swap a 1 with an adjacent 0 (costs 1 move). If the 1 moves to Alice's position, she picks it up

Goal: Return the minimum number of moves needed to collect exactly k ones.

Example: With nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1, Alice could start at index 5, pick up that 1 for free, create a 1 at index 4 (1 move), then swap it to her position (1 move), and swap the 1 from index 6 to her position (1 move). Total: 3 moves for 3 ones.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1

› Output: 3

💡 Note: Alice can start at index 5 (has a 1), create a 1 at index 4 using maxChanges (1 move), swap it to position 5 (1 move), then swap the 1 from index 6 to position 5 (1 move). Total: 3 moves to collect 3 ones.

example_2.py — Use MaxChanges Optimally

$ Input: nums = [0,0,0,0], k = 2, maxChanges = 3

› Output: 4

💡 Note: No existing ones, so Alice must create all ones using maxChanges. She can start anywhere, create a 1 at her position (1 move), pick it up (1 move), create another 1 (1 move), pick it up (1 move). Total: 4 moves for 2 ones.

example_3.py — Adjacent Ones Advantage

$ Input: nums = [1,1,1,1,1], k = 3, maxChanges = 0

› Output: 2

💡 Note: Alice should start at index 2 (middle). She gets 1 one for free at her position, then can swap adjacent ones at indices 1 and 3 to her position (1 move each). Total: 2 moves for 3 ones.

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
1 ≤ k ≤ nums.length
0 ≤ maxChanges ≤ 10⁹
The answer is guaranteed to exist

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses a greedy strategy combined with sliding window technique. Key insights: (1) Try each position as Alice's starting point, (2) Greedily collect free ones at start position and adjacent positions, (3) Use maxChanges optimally to create ones at Alice's position (2 moves each), (4) For remaining ones, use sliding window to find the minimum collection distance from existing ones. Time complexity: O(n²) for trying all positions with sliding window optimization.

Common Approaches

✓ Brute Force (Try All Positions)

⏱️ Time: O(n * 2^n) Space: O(n)

For each possible starting position, calculate the minimum moves needed by trying all combinations of creating new ones vs collecting existing ones. This involves checking every possible way to use maxChanges and every possible subset of existing ones to collect.

Greedy + Sliding Window (Optimal)

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

The key insight is to use a greedy approach: first maximize free pickups (at start + adjacent), then use maxChanges optimally (create at Alice's position), finally collect remaining ones using sliding window to minimize total swapping distance.

Brute Force (Try All Positions) — Algorithm Steps

Try each index as starting position
For each position, enumerate all ways to use maxChanges
For remaining ones needed, find optimal subset of existing ones
Calculate total moves for each combination
Return minimum across all starting positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Position 0

Calculate minimum moves if Alice starts at index 0

Try Position 1

Calculate minimum moves if Alice starts at index 1

Continue...

Repeat for all positions and take the minimum

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int solveFromPosition(int* nums, int numsSize, int k, int maxChanges, int start) {
    int onesPositions[numsSize];
    int onesCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == 1 && i != start) {
            onesPositions[onesCount++] = i;
        }
    }
    
    int collected = nums[start] == 1 ? 1 : 0;
    
    if (collected >= k) return 0;
    
    int minMoves = INT_MAX;
    int maxChangesToUse = maxChanges < (k - collected) ? maxChanges : (k - collected);
    
    for (int changesUsed = 0; changesUsed <= maxChangesToUse; changesUsed++) {
        int remainingNeeded = k - collected - changesUsed;
        
        if (remainingNeeded <= 0) {
            int moveCost = changesUsed * 2;
            if (moveCost < minMoves) {
                minMoves = moveCost;
            }
            continue;
        }
        
        if (remainingNeeded > onesCount) continue;
        
        int distances[onesCount];
        for (int i = 0; i < onesCount; i++) {
            distances[i] = abs(onesPositions[i] - start);
        }
        qsort(distances, onesCount, sizeof(int), compare);
        
        int moveCost = changesUsed * 2;
        for (int i = 0; i < remainingNeeded; i++) {
            moveCost += distances[i];
        }
        
        if (moveCost < minMoves) {
            minMoves = moveCost;
        }
    }
    
    return minMoves == INT_MAX ? -1 : minMoves;
}

int minimumMoves(int* nums, int numsSize, int k, int maxChanges) {
    int minMoves = INT_MAX;
    
    for (int start = 0; start < numsSize; start++) {
        int moves = solveFromPosition(nums, numsSize, k, maxChanges, start);
        if (moves < minMoves) {
            minMoves = moves;
        }
    }
    
    return minMoves;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n * 2^n)

For each of n starting positions, we potentially check all 2^n subsets of ones

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing positions

⚡ Linearithmic Space

26.0K Views

Medium Frequency

~35 min Avg. Time

847 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 Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler