Minimized Maximum of Products Distributed to Any Store - Problem

You are given an integer n indicating there are n specialty retail stores. There are m product types of varying amounts, which are given as a 0-indexed integer array quantities, where quantities[i] represents the number of products of the i-th product type.

You need to distribute all products to the retail stores following these rules:

A store can only be given at most one product type but can be given any amount of it.
After distribution, each store will have been given some number of products (possibly 0). Let x represent the maximum number of products given to any store. You want x to be as small as possible, i.e., you want to minimize the maximum number of products that are given to any store.

Return the minimum possible x.

Input & Output

Example 1 — Basic Case

$ Input: n = 6, quantities = [11,6]

› Output: 3

💡 Note: With max 3 per store: Product type 0 needs ceil(11/3) = 4 stores, product type 1 needs ceil(6/3) = 2 stores. Total: 4 + 2 = 6 stores ≤ 6.

Example 2 — Single Product Type

$ Input: n = 7, quantities = [15]

› Output: 3

💡 Note: Only one product type with 15 units. With max 3 per store: ceil(15/3) = 5 stores ≤ 7. With max 2: ceil(15/2) = 8 stores > 7. So minimum possible maximum is 3.

Example 3 — Multiple Small Quantities

$ Input: n = 1, quantities = [100000]

› Output: 100000

💡 Note: Only 1 store available, so it must take all 100000 products of the single type.

Constraints

m == quantities.length
1 ≤ m ≤ n ≤ 10⁵
1 ≤ quantities[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 A Amazon 12 M Microsoft 8

The key insight is to binary search on the answer space - the maximum number of products any store can receive. We can check if a given maximum works by calculating how many stores each product type needs (using ceiling division) and ensuring the total doesn't exceed n. Best approach is binary search on answer space with Time: O(log(max) × m), Space: O(1).

Common Approaches

✓ Binary Search on Answer Space

⏱️ Time: O(log(max(quantities)) × m) Space: O(1)

Instead of trying every possible maximum linearly, we binary search on the answer space from 1 to max(quantities). For each candidate maximum, we check if it's possible to distribute all products using at most n stores.

Linear Search on Answer

⏱️ Time: O(max(quantities) × m) Space: O(1)

For each possible maximum x from 1 to max(quantities), check if we can distribute all products using at most n stores where no store gets more than x products of its assigned type.

Binary Search on Answer Space — Algorithm Steps

Step 1: Set search range from 1 to max(quantities)
Step 2: For mid value, check if distribution is possible
Step 3: If possible, search left half; otherwise search right half
Step 4: Return the minimum working maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Range

Search space from 1 to max(quantities)

Test Middle

Check if mid value allows valid distribution

Narrow Range

Eliminate half of search space based on result

Code -

solution.c — C

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

int canDistribute(int maxPerStore, int n, int* quantities, int size) {
    int storesNeeded = 0;
    for (int i = 0; i < size; i++) {
        storesNeeded += (quantities[i] + maxPerStore - 1) / maxPerStore; // Ceiling division
    }
    return storesNeeded <= n;
}

int solution(int n, int* quantities, int size) {
    int left = 1, right = 0;
    for (int i = 0; i < size; i++) {
        if (quantities[i] > right) {
            right = quantities[i];
        }
    }
    int result = right;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canDistribute(mid, n, quantities, size)) {
            result = mid;  // This works, try to find smaller
            right = mid - 1;
        } else {
            left = mid + 1;  // Need larger maximum
        }
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    scanf(" %s", line);
    
    // Parse array manually
    int quantities[1000];
    int size = 0;
    char* ptr = line + 1; // Skip opening bracket
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        quantities[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(n, quantities, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log(max(quantities)) × m)

Binary search takes log(max) iterations, each iteration checks all m product types

✓ Linear Growth

Space Complexity

O(1)

Only using variables for binary search bounds and calculations

✓ Linear Space

23.4K Views

Medium Frequency

~25 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

Minimized Maximum of Products Distributed to Any Store - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer Space — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler