Fair Distribution of Cookies - Practice Coding Problems

Fair Distribution of Cookies - Problem

Imagine you're a parent trying to fairly distribute bags of cookies among your children for a school event. You have several bags, each containing different amounts of cookies, and you need to give all bags to your k children.

Here's the challenge: each bag must go to exactly one child (you can't split a bag), and you want to minimize the maximum number of cookies any single child receives. This creates the most "fair" distribution possible.

Given an integer array cookies where cookies[i] represents the number of cookies in the i-th bag, and an integer k representing the number of children, return the minimum possible unfairness.

The unfairness is defined as the maximum total cookies obtained by any single child in the distribution.

Input & Output

example_1.py — Basic Distribution

$ Input: cookies = [8,15,10,20,8], k = 2

› Output: 31

💡 Note: One optimal distribution is [8,15,8] and [10,20]. Child 1 gets 31 cookies, child 2 gets 30 cookies. The unfairness is max(31,30) = 31.

example_2.py — Equal Distribution

$ Input: cookies = [6,1,3,2,2,4,1,2], k = 3

› Output: 7

💡 Note: One optimal distribution is [6,1], [3,2,2] and [4,1,2]. Each child gets 7 cookies, so unfairness is 7.

example_3.py — Single Large Bag

$ Input: cookies = [1,1,1,100], k = 2

› Output: 100

💡 Note: The large bag of 100 cookies must go to one child, so minimum unfairness is 100. Best distribution: [1,1,1] and [100].

Visualization

Tap to expand

Understanding the Visualization

Start with empty hands

All children start with 0 cookies

Pick up first bag

Decide which child gets this bag of cookies

Try all possibilities

Recursively try giving each remaining bag to each child

Track the 'luckiest' child

Keep track of maximum cookies any child has

Find minimum unfairness

Return the distribution where the luckiest child has minimum cookies

Key Takeaway

🎯 Key Insight: Use backtracking with early pruning - if current distribution already exceeds our best answer, abandon that path immediately to dramatically reduce search space.

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

For each of n bags, we try k children, leading to k^n total combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals number of bags

⚡ Linearithmic Space

Constraints

2 ≤ cookies.length ≤ 8
1 ≤ cookies[i] ≤ 10⁵
2 ≤ k ≤ cookies.length
All bags must be distributed - no bag can be left unassigned

Asked in

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

This problem requires backtracking with pruning for optimal results. The key insight is to eliminate branches early when current unfairness exceeds our best known answer. Binary search on the answer can also work but requires careful validation. Time complexity ranges from O(k^n) for basic backtracking to optimized versions with significant pruning.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Backtracking	O(k^n)	O(n)	Try every possible way to assign bags to children recursively
Binary Search + Greedy	O(log(sum) × k^n)	O(n)	Binary search on answer, use greedy to check if distribution is possible

Brute Force Backtracking — Algorithm Steps

For each cookie bag, try assigning it to each of the k children
Recursively solve for the remaining bags
Track the maximum cookies any child has in current distribution
Return the minimum unfairness across all valid distributions
Use backtracking to undo assignments and try alternatives

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first bag

Try assigning bag 0 to each of k children

Recurse for next bag

For each assignment, recursively solve remaining bags

Backtrack and try alternatives

Undo assignment and try next child

Track minimum unfairness

Keep track of best distribution found so far

Code -

solution.c — C

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

int max(int* arr, int size) {
    int maxVal = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > maxVal) maxVal = arr[i];
    }
    return maxVal;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int backtrack(int index, int* cookies, int cookiesSize, int* children, int k) {
    if (index == cookiesSize) {
        return max(children, k);
    }
    
    int minUnfairness = INT_MAX;
    for (int i = 0; i < k; i++) {
        children[i] += cookies[index];
        minUnfairness = min(minUnfairness, backtrack(index + 1, cookies, cookiesSize, children, k));
        children[i] -= cookies[index];
    }
    
    return minUnfairness;
}

int distributeCookies(int* cookies, int cookiesSize, int k) {
    int* children = (int*)calloc(k, sizeof(int));
    int result = backtrack(0, cookies, cookiesSize, children, k);
    free(children);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

For each of n bags, we try k children, leading to k^n total combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals number of bags

⚡ Linearithmic Space

Constraints

2 ≤ cookies.length ≤ 8
1 ≤ cookies[i] ≤ 10⁵
2 ≤ k ≤ cookies.length
All bags must be distributed - no bag can be left unassigned

21.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler