Fair Distribution of Cookies

Fair Distribution of Cookies - Problem

You are given an integer array cookies, where cookies[i] denotes the number of cookies in the i-th bag. You are also given an integer k that denotes the number of children to distribute all the bags of cookies to.

All the cookies in the same bag must go to the same child and cannot be split up.

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

Return the minimum unfairness of all distributions.

Input & Output

Example 1 — Basic Distribution

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

› Output: 31

💡 Note: Optimal distribution: Child 1 gets [8,15,8] = 31, Child 2 gets [10,20] = 30. Maximum is 31.

Example 2 — Equal Distribution

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

› Output: 7

💡 Note: One optimal way: Child 1: [6,1] = 7, Child 2: [3,2,2] = 7, Child 3: [4,1,2] = 7. All children get 7 cookies.

Example 3 — Single Large Bag

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

› Output: 20

💡 Note: Child 1 gets [1,1,1,1] = 4, Child 2 gets [20] = 20. The large bag determines the minimum unfairness.

Constraints

2 ≤ cookies.length ≤ 8
1 ≤ cookies[i] ≤ 10⁵
2 ≤ k ≤ cookies.length

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 15

The key insight is to use backtracking with aggressive pruning to explore all possible distributions while eliminating branches that cannot improve the answer. The optimized backtracking approach sorts bags in descending order, prunes branches when current maximum exceeds the best found, and avoids duplicate assignments to empty children. Time: O(k^n) with significant pruning, Space: O(n)

Common Approaches

✓ Backtracking All Distributions

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

Use backtracking to generate all possible distributions of bags to children. For each distribution, calculate the maximum cookies any child receives and track the minimum across all distributions.

Backtracking with Pruning

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

Improve the basic backtracking by adding pruning techniques: skip branches when current maximum already exceeds the best found solution, and avoid assigning bags to empty children when non-empty children exist.

Binary Search on Answer

⏱️ Time: O(n * log(sum)) Space: O(k)

Instead of trying all distributions, binary search on the possible unfairness values. For each candidate value, use greedy assignment to check if it's possible to distribute all bags such that no child gets more than that amount.

Backtracking All Distributions — Algorithm Steps

For each bag, try assigning it to each of the k children
Recursively distribute remaining bags
Calculate maximum cookies per child for complete distribution
Return minimum unfairness across all distributions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with empty assignments for all children

Recurse

For each bag, try assigning to each child

Track Minimum

Record the minimum maximum unfairness found

Code -

solution.c — C

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

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

int backtrack(int* cookies, int n, int* children, int k, int bagIdx, int minUnfairness) {
    if (bagIdx == n) {
        int maxCookies = maxInArray(children, k);
        return (maxCookies < minUnfairness) ? maxCookies : minUnfairness;
    }
    
    // Pruning
    int currentMax = maxInArray(children, k);
    if (currentMax >= minUnfairness) {
        return minUnfairness;
    }
    
    for (int child = 0; child < k; child++) {
        children[child] += cookies[bagIdx];
        minUnfairness = backtrack(cookies, n, children, k, bagIdx + 1, minUnfairness);
        children[child] -= cookies[bagIdx];
    }
    
    return minUnfairness;
}

int solution(int* cookies, int n, int k) {
    int* children = (int*)calloc(k, sizeof(int));
    int result = backtrack(cookies, n, children, k, 0, INT_MAX);
    free(children);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse cookies array manually
    int cookies[20];
    int n = 0;
    char* ptr = line + 1; // Skip [
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        cookies[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(cookies, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

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

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack depth of n plus array to track child totals

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

856 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

Backtracking All Distributions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler