Minimum Rounds to Complete All Tasks

Minimum Rounds to Complete All Tasks - Problem

You are given a 0-indexed integer array tasks, where tasks[i] represents the difficulty level of a task.

In each round, you can complete either 2 or 3 tasks of the same difficulty level.

Return the minimum rounds required to complete all the tasks, or -1 if it is not possible to complete all the tasks.

Input & Output

Example 1 — Mixed Difficulties

$ Input: tasks = [2,2,3,3,2,4,4,4,4,4]

› Output: 4

💡 Note: Difficulty 2: 3 tasks → 1 round of 3. Difficulty 3: 2 tasks → 1 round of 2. Difficulty 4: 5 tasks → 1 round of 3 + 1 round of 2 = 2 rounds. Total: 1+1+2=4

Example 2 — Perfect Groups

$ Input: tasks = [2,3,3]

› Output: -1

💡 Note: Difficulty 2: 1 task cannot be completed (need at least 2 tasks of same difficulty per round)

Example 3 — All Same Difficulty

$ Input: tasks = [5,5,5,5,5,5]

› Output: 2

💡 Note: 6 tasks of difficulty 5 can be completed in 2 rounds of 3 tasks each

Constraints

1 ≤ tasks.length ≤ 10⁵
1 ≤ tasks[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 30 M Microsoft 25

The key insight is that tasks with frequency 1 are impossible to complete, while all other frequencies can be optimally handled using greedy math. Best approach is Frequency Count with Greedy Math: prefer groups of 3 over groups of 2 to minimize total rounds. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Combinations

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

Count frequency of each task difficulty, then for each difficulty try every possible combination of rounds with 2 tasks and rounds with 3 tasks to find the minimum total rounds.

Frequency Count with Greedy Math

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

Count frequency of each task difficulty, then for each frequency use mathematical formula to find minimum rounds. Prefer groups of 3 over groups of 2 since 3 is more efficient.

Brute Force - Try All Combinations — Algorithm Steps

Count frequency of each task difficulty
For each difficulty, try all combinations of 2s and 3s
Return minimum rounds or -1 if impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many tasks of each difficulty

Try Combinations

For each difficulty, try all ways to group into 2s and 3s

Sum Minimum

Add up the minimum rounds for each difficulty

Code -

solution.c — C

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

#define HASH_SIZE 100003

typedef struct Node {
    int key;
    int value;
    struct Node* next;
} Node;

typedef struct {
    Node* buckets[HASH_SIZE];
} HashMap;

int hash(int key) {
    return (key % HASH_SIZE + HASH_SIZE) % HASH_SIZE;
}

void put(HashMap* map, int key, int value) {
    int index = hash(key);
    Node* node = map->buckets[index];
    while (node) {
        if (node->key == key) {
            node->value = value;
            return;
        }
        node = node->next;
    }
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->key = key;
    newNode->value = value;
    newNode->next = map->buckets[index];
    map->buckets[index] = newNode;
}

int get(HashMap* map, int key) {
    int index = hash(key);
    Node* node = map->buckets[index];
    while (node) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    return 0;
}

void increment(HashMap* map, int key) {
    put(map, key, get(map, key) + 1);
}

int solution(int* tasks, int tasksSize) {
    HashMap freq = {0};
    
    for (int i = 0; i < tasksSize; i++) {
        increment(&freq, tasks[i]);
    }
    
    int totalRounds = 0;
    
    for (int i = 0; i < HASH_SIZE; i++) {
        Node* node = freq.buckets[i];
        while (node) {
            int count = node->value;
            if (count == 1) return -1;
            
            int minRounds = INT_MAX;
            // Try all combinations of 2s and 3s
            for (int threes = 0; threes <= count / 3; threes++) {
                int remaining = count - 3 * threes;
                if (remaining % 2 == 0) {
                    int twos = remaining / 2;
                    int rounds = threes + twos;
                    if (rounds < minRounds) {
                        minRounds = rounds;
                    }
                }
            }
            
            if (minRounds == INT_MAX) return -1;
            totalRounds += minRounds;
            node = node->next;
        }
    }
    
    return totalRounds;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int tasks[10000];
    int tasksSize = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        tasks[tasksSize++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    int result = solution(tasks, tasksSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × max_freq²)

Count frequencies in O(n), then for each unique difficulty try O(max_freq²) combinations

✓ Linear Growth

Space Complexity

O(n)

Hash map to store frequency of each task difficulty

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

892 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