Maximum Number of Groups Getting Fresh Donuts

Maximum Number of Groups Getting Fresh Donuts - Problem

Imagine you're managing a donut shop that operates with a unique serving system! The shop bakes donuts in fixed batches of size batchSize, and must serve all donuts from one batch before starting the next.

You have multiple customer groups coming to your shop, where groups[i] represents the number of customers in the i-th group. Each customer gets exactly one donut, and all customers in a group must be served together before serving the next group.

Here's the key: A group is "happy" if they get fresh donuts - meaning the first customer in their group doesn't receive a leftover donut from the previous group's batch.

Your goal is to rearrange the order of groups to maximize the number of happy groups. Can you figure out the optimal arrangement?

Example: If batchSize = 3 and groups = [1, 2, 3, 4, 5, 6], you need to strategically order these groups so that as many as possible start with a fresh batch!

Input & Output

example_1.py — Basic Case

$ Input: batchSize = 3, groups = [1, 2, 3, 4, 5, 6]

› Output: 4

💡 Note: We can arrange groups as [6, 1, 2, 3, 4, 5]. Groups 6, 1, 3, and 5 start fresh batches (remainders: 0→0, 0→1, 0→0, 2→0), making 4 happy groups total.

example_2.py — Small Batch

$ Input: batchSize = 4, groups = [1, 3, 2, 5, 2, 2, 1, 6]

› Output: 4

💡 Note: With batchSize=4, remainders are [1,3,2,1,2,2,1,2]. Optimal arrangement can make groups with remainders 0, 3+1=4≡0, 2+2=4≡0, 1+3=4≡0 start fresh batches.

example_3.py — Edge Case

$ Input: batchSize = 2, groups = [1, 1, 1]

› Output: 2

💡 Note: All groups have remainder 1. We can pair two groups (1+1=2≡0) to start fresh, so arrangement [1,1,1] gives happy groups at positions 1 and 3, total = 2.

Visualization

Tap to expand

Understanding the Visualization

Analyze Remainders

Convert group sizes to remainders mod batchSize - only these matter for batch management

Count Frequencies

Create frequency array showing how many groups need each remainder amount

DP with Memoization

Use recursive function to try all valid group placements, caching results to avoid recomputation

Optimize Placement

For each state, try placing each available group type and pick the arrangement yielding maximum happy groups

Key Takeaway

🎯 Key Insight: By converting group sizes to remainders and using state compression with memoization, we transform an exponential problem into a manageable dynamic programming solution that efficiently explores all valid arrangements.

Time & Space Complexity

Time Complexity

⏱️

O(batchSize^n)

In practice much better due to memoization and state pruning

✓ Linear Growth

Space Complexity

O(batchSize^n)

Space for memoization table storing unique states

⚡ Linearithmic Space

Constraints

1 ≤ batchSize ≤ 9
1 ≤ groups.length ≤ 30
1 ≤ groups[i] ≤ 10⁹
Key insight: Only remainders modulo batchSize matter, not actual group sizes

Asked in

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

The optimal approach uses dynamic programming with state compression and memoization. Key insights: (1) Only remainders modulo batchSize matter, not actual group sizes. (2) We can represent states by frequency counts of each remainder type. (3) Memoized recursion explores all state transitions while avoiding redundant computations, achieving much better performance than brute force permutation testing.

Common Approaches

Approach	Time	Space	Notes
✓ Memoized DP with State Compression (Optimal)	O(batchSize^n)	O(batchSize^n)	Use dynamic programming with memoization on compressed remainder frequency states
Brute Force (Try All Permutations)	O(n! × n)	O(n)	Generate all possible orderings of groups and count happy groups for each

Memoized DP with State Compression (Optimal) — Algorithm Steps

Convert all group sizes to their remainders modulo batchSize
Count frequency of each remainder type (0 to batchSize-1)
Use memoized recursion with state = (freq[0], freq[1], ..., freq[k-1], current_remainder)
For each state, try placing each available remainder type
Memoize results to avoid recomputing identical states
Return maximum happy groups achievable from initial state

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Remainders

Transform group sizes to remainders mod batchSize

Count Frequencies

Create frequency array for each remainder type

Memoized Recursion

Recursively try placing each remainder type with memoization

Code -

solution.c — C

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

#define MAX_BATCH_SIZE 30
#define MAX_GROUPS 30
#define MEMO_SIZE 100000

typedef struct {
    char key[200];
    int value;
} MemoEntry;

MemoEntry memo[MEMO_SIZE];
int memoCount = 0;
int batchSize;

int findMemo(const char* key) {
    for (int i = 0; i < memoCount; i++) {
        if (strcmp(memo[i].key, key) == 0) {
            return memo[i].value;
        }
    }
    return -1;
}

void addMemo(const char* key, int value) {
    if (memoCount < MEMO_SIZE) {
        strcpy(memo[memoCount].key, key);
        memo[memoCount].value = value;
        memoCount++;
    }
}

int dp(int* state, int remainder) {
    char key[200] = "";
    for (int i = 0; i < batchSize; i++) {
        char temp[10];
        sprintf(temp, "%d,", state[i]);
        strcat(key, temp);
    }
    char temp[10];
    sprintf(temp, "|%d", remainder);
    strcat(key, temp);
    
    int cached = findMemo(key);
    if (cached != -1) return cached;
    
    int result = 0;
    
    for (int i = 0; i < batchSize; i++) {
        if (state[i] > 0) {
            state[i]--;
            int newRemainder = (remainder + i) % batchSize;
            int happyBonus = remainder == 0 ? 1 : 0;
            
            int subResult = happyBonus + dp(state, newRemainder);
            if (subResult > result) result = subResult;
            
            state[i]++;
        }
    }
    
    addMemo(key, result);
    return result;
}

int maxHappyGroups(int bs, int* groups, int size) {
    batchSize = bs;
    memoCount = 0;
    
    int freq[MAX_BATCH_SIZE] = {0};
    for (int i = 0; i < size; i++) {
        freq[groups[i] % batchSize]++;
    }
    
    int alwaysHappy = freq[0];
    freq[0] = 0;
    
    return alwaysHappy + dp(freq, 0);
}

int main() {
    int batchSize;
    scanf("%d", &batchSize);
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    fgets(line, sizeof(line), stdin);
    
    int groups[MAX_GROUPS], size = 0;
    char* token = strtok(line, " \n");
    while (token != NULL && size < MAX_GROUPS) {
        groups[size++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%d\n", maxHappyGroups(batchSize, groups, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(batchSize^n)

In practice much better due to memoization and state pruning

✓ Linear Growth

Space Complexity

O(batchSize^n)

Space for memoization table storing unique states

⚡ Linearithmic Space

Constraints

1 ≤ batchSize ≤ 9
1 ≤ groups.length ≤ 30
1 ≤ groups[i] ≤ 10⁹
Key insight: Only remainders modulo batchSize matter, not actual group sizes

28.5K Views

Medium Frequency

~35 min Avg. Time

950 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Memoized DP with State Compression (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler