Minimum Moves to Pick K Ones - Practice Coding Problems

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

Understanding the Visualization

Choose Optimal Starting Point

Alice evaluates each position to maximize free treasures nearby

Collect Free Treasures

Pick up treasure at current position (free) and adjacent treasures (1 move each)

Use Magic Wisely

Create treasures at Alice's position using maxChanges (2 moves per treasure: create + collect)

Gather Remaining Treasures

Use sliding window to find closest existing treasures and minimize total swapping distance

Key Takeaway

🎯 Key Insight: The optimal strategy combines greedy local collection (adjacent ones) with strategic use of maxChanges, then applies sliding window technique to minimize the distance when collecting remaining ones from existing positions.

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

Approach	Time	Space	Notes
✓ Brute Force (Try All Positions)	O(n * 2^n)	O(n)	Try every starting position and simulate optimal moves from each
Greedy + Sliding Window (Optimal)	O(n²)	O(n)	Use greedy strategy with sliding window to minimize collection 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