Minimum Operations to Collect Elements

Minimum Operations to Collect Elements - Problem

You are given an array nums of positive integers and an integer k.

In one operation, you can remove the last element of the array and add it to your collection.

Return the minimum number of operations needed to collect elements 1, 2, ..., k.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,1,5,4,2], k = 2

› Output: 4

💡 Note: Working backwards: remove 2 (have {2}), remove 4 (have {2}), remove 5 (have {2}), remove 1 (have {1,2}). We need 4 operations to collect both 1 and 2.

Example 2 — Numbers at End

$ Input: nums = [3,1,3,2,2], k = 1

› Output: 4

💡 Note: Need to collect number 1. Working backwards: remove 2 (not ≤ 1), remove 2 (not ≤ 1), remove 3 (not ≤ 1), remove 1 (have {1}). We need 4 operations to collect 1.

Example 3 — All Numbers Present

$ Input: nums = [2,1,3], k = 2

› Output: 3

💡 Note: Working backwards: remove 3 (not needed), remove 1 (have {1}), remove 2 (have {1,2}). Need 3 operations total.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ k ≤ nums.length
1 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

M Meta 15 A Amazon 12 G Google 8

The key insight is to work backwards from the end of the array, collecting elements until we have all numbers from 1 to k. Best approach uses a single pass with early termination. Time: O(n), Space: O(k)

Common Approaches

✓ Brute Force - Try All Combinations

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

Try every possible way to remove elements from the end and check if we have collected all numbers from 1 to k. This involves checking all possible stopping points.

Single Pass from End

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

Start from the end of the array and move backwards, keeping track of which numbers from 1 to k we've collected. Stop as soon as we have all required numbers.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: For each possible number of operations from 1 to n
Step 2: Check if removing that many elements gives us all numbers 1 to k
Step 3: Return the minimum operations needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Try 1 Operation

Remove last element, check if we have 1,2,...,k

Try 2 Operations

Remove last 2 elements, check collection

Continue

Keep trying until we collect all needed numbers

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int k) {
    for (int ops = 1; ops <= numsSize; ops++) {
        bool collected[100001] = {false};
        int count = 0;
        for (int i = 0; i < ops; i++) {
            int element = nums[numsSize - 1 - i];
            if (element <= k && !collected[element]) {
                collected[element] = true;
                count++;
            }
        }
        if (count == k) {
            bool hasAll = true;
            for (int i = 1; i <= k; i++) {
                if (!collected[i]) {
                    hasAll = false;
                    break;
                }
            }
            if (hasAll) return ops;
        }
    }
    return numsSize;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n possible operations, we check up to n elements

⚠ Quadratic Growth

Space Complexity

O(k)

Set to track collected elements, size at most k

✓ Linear Space

15.0K Views

Medium Frequency

~15 min Avg. Time

450 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 Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler