Maximum Candies Allocated to K Children - Practice Coding Problems

Maximum Candies Allocated to K Children - Problem

🍭 Maximum Candies Allocated to K Children

Imagine you're managing a candy distribution system for k children at a school party! You have several piles of candies, where each pile contains a different number of candies. Here's the challenge:

📋 The Rules:
• You can split any pile into smaller sub-piles of any size
• You cannot merge two different piles together
• Each child must receive candies from exactly one pile (or sub-pile)
• All children must get the same amount of candies
• Some piles can remain unused

🎯 Your Goal: Find the maximum number of candies each child can receive while following these rules.

Example: If you have piles [5, 8, 6] and k = 3 children, you could split the pile of 8 into two sub-piles of 4 each, then give one child 5 candies, and two children 4 candies each. But to give everyone the same amount, the maximum would be 4 candies per child (split 8→4+4, and 6→4+2, leaving pile 5 unused).

Input & Output

example_1.py — Basic Distribution

$ Input: candies = [5, 8, 6], k = 3

› Output: 5

💡 Note: We can give each child 5 candies. Child 1 gets all 5 from pile 1, child 2 gets 5 from pile 2 (leaving 3), and child 3 gets 5 from pile 3 (leaving 1). All three children get exactly 5 candies each.

example_2.py — Need to Split Piles

$ Input: candies = [2, 5], k = 11

› Output: 0

💡 Note: Total candies = 2 + 5 = 7, but we need to serve 11 children. Even if we give each child just 1 candy, we can only serve 7 children maximum. Therefore, it's impossible to give each child the same positive amount.

example_3.py — Large Pile Optimization

$ Input: candies = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1000000], k = 10

› Output: 100000

💡 Note: We have 10 piles of 1 candy each and one huge pile of 1,000,000. We can split the large pile into 10 sub-piles of 100,000 candies each, giving each of the 10 children exactly 100,000 candies. The small piles remain unused.

Constraints

1 ≤ candies.length ≤ 10⁵
1 ≤ candies[i] ≤ 10⁷
1 ≤ k ≤ 10¹²
Note: k can be very large (up to 10¹²), much larger than the array size

Visualization

Tap to expand

Step 1: Test mid = 4 → Can serve 1+2+1 = 4 children ≥ 3 ✓ (try larger)🔍 Step 2: Test mid = 6 → Can serve 0+1+1 = 2 children < 3 ✗ (try smaller)🔍 Step 3: Test mid = 5 → Can serve 1+1+1 = 3 children ≥ 3 ✓ (optimal!)💡 Key Insights• Monotonic Property: If X candies per child works, then X-1, X-2, ... also work• Efficient Search: Binary search reduces O(max_candies) to O(log max_candies)

Understanding the Visualization

Survey Resources

Look at all your candy piles and note the largest pile (this sets your upper limit)

Binary Search Strategy

Instead of testing every portion size, use binary search to efficiently find the maximum feasible portion

Feasibility Check

For each candidate portion size, calculate how many children you can serve by dividing each pile

Converge to Optimal

Keep narrowing your search until you find the largest portion size that serves all k children

Key Takeaway

🎯 Key Insight: This problem transforms from 'how to distribute' to 'what's the maximum we can distribute equally' - a perfect setup for binary search on the answer!

Asked in

f Meta 45 a Amazon 38 G Google 32 ⊞ Microsoft 28

This problem is a classic binary search on answer pattern. The key insight is recognizing the monotonic property: if we can distribute X candies to each child, we can definitely distribute X-1 candies to each child. We binary search on the answer range [1, max(candies)] and for each candidate amount, check if we can serve at least k children by calculating sum(pile // amount) across all piles. The optimal solution runs in O(n log max_candies) time.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer (Optimal)	O(n log max_candies)	O(1)	Binary search on the possible candy amounts to find maximum feasible value
Brute Force (Linear Search)	O(max_candies × n)	O(1)	Try every possible candy amount from 1 to maximum pile size

Binary Search on Answer (Optimal) — Algorithm Steps

Set left = 1, right = max(candies) for binary search bounds
While left <= right:
Calculate mid = (left + right) // 2
Check if we can serve k children with 'mid' candies each
Count total portions: sum(pile // mid for pile in candies)
If total portions >= k: answer = mid, search right half (left = mid + 1)
Else: search left half (right = mid - 1)
Return the maximum feasible amount found

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Bounds

Initialize left=1, right=max_pile_size

Test Middle

Calculate mid and test if we can serve k children

Adjust Range

If feasible, search right half; otherwise left half

Converge

Continue until we find the maximum feasible amount

Code -

solution.c — C

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

bool canDistribute(int* candies, int candiesSize, int amount, long long k) {
    long long totalChildren = 0;
    for (int i = 0; i < candiesSize; i++) {
        totalChildren += candies[i] / amount;
        if (totalChildren >= k) return true;  // Early termination
    }
    return totalChildren >= k;
}

int maximumCandies(int* candies, int candiesSize, long long k) {
    if (candiesSize == 0 || k == 0) {
        return 0;
    }
    
    int maxCandies = 0;
    for (int i = 0; i < candiesSize; i++) {
        if (candies[i] > maxCandies) {
            maxCandies = candies[i];
        }
    }
    
    int left = 1, right = maxCandies;
    int result = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        
        if (canDistribute(candies, candiesSize, mid, k)) {
            result = mid;  // Found a valid amount
            left = mid + 1;  // Try to find a larger amount
        } else {
            right = mid - 1;  // Amount too large, try smaller
        }
    }
    
    return result;
}

int main() {
    int n;
    long long k;
    scanf("%d %lld", &n, &k);
    
    int* candies = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &candies[i]);
    }
    
    printf("%d\n", maximumCandies(candies, n, k));
    free(candies);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log max_candies)

Binary search runs in O(log max_candies) iterations, each iteration checks all n piles in O(n) time

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant amount of extra space for binary search variables

✓ Linear Space

42.3K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Binary Search on Answer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler