Minimized Maximum of Products Distributed to Any Store

Minimized Maximum of Products Distributed to Any Store - Problem

Imagine you're a distribution manager for a retail chain! You have n specialty stores and m different product types with varying quantities that need to be distributed efficiently.

You're given an integer n representing the number of specialty retail stores, and an array quantities where quantities[i] represents the number of products of the i-th product type.

Distribution Rules:

Each store can receive at most one product type (but any amount of that type)
All products must be distributed
Some stores may receive no products at all

Goal: Minimize the maximum number of products any single store receives. If x represents the maximum products given to any store, find the smallest possible value of x.

Example: With 6 stores and quantities [11, 6], you could give 11 products of type 1 to store 1, and 6 products of type 2 to store 2. But you could also split: give 6 products of type 1 to store 1, 5 to store 2, and 6 of type 2 to store 3. The maximum would be 6 instead of 11!

Input & Output

example_1.py — Basic Distribution

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

› Output: 3

💡 Note: We can distribute 11 products of type 1 across 4 stores (3+3+3+2) and 6 products of type 2 across 2 stores (3+3). Maximum per store is 3.

example_2.py — Single Product Type

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

› Output: 3

💡 Note: With 15 products of one type and 7 stores, optimal distribution is 3+3+3+3+2+1+0 = 15. Maximum is 3.

example_3.py — More Stores Than Needed

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

› Output: 100000

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

Visualization

Tap to expand

Understanding the Visualization

Identify Search Space

Minimum possible max is 1, maximum possible is max(quantities)

Binary Search on Answer

For each candidate maximum, check if feasible distribution exists

Feasibility Check

Calculate stores needed: sum of ceil(qty/maxProducts) for all products

Narrow Search Space

If feasible, try smaller max; if not, increase max

Key Takeaway

🎯 Key Insight: Binary search on answer space works because feasibility is monotonic - if we can distribute with maximum X, we can definitely do it with X+1, X+2, etc. This reduces time complexity from O(m × max) to O(m log max)!

Time & Space Complexity

Time Complexity

⏱️

O(max(quantities) * m)

We try each possible maximum value and for each one, we check all m product types

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for calculation

✓ Linear Space

Constraints

m == quantities.length
1 ≤ m ≤ n ≤ 10⁵
1 ≤ quantities[i] ≤ 10⁵
Key insight: We always have enough stores (n ≥ m)

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 12 f Meta 8

The optimal approach uses binary search on the answer space. Since feasibility is monotonic (if max x works, then x+1, x+2... also work), we can binary search for the minimum feasible maximum. For each candidate maximum, we check if distribution is possible by calculating required stores: ceil(quantity/max) for each product type. Time complexity: O(m log max(quantities)).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Linear Search	O(max(quantities) * m)	O(1)	Try every possible maximum from 1 to max(quantities), check if distribution is feasible
Binary Search on Answer (Optimal)	O(m * log(max(quantities)))	O(1)	Binary search on the answer space since feasibility is monotonic

Brute Force Linear Search — Algorithm Steps

Start with x = 1 and iterate up to max(quantities)
For each x, calculate how many stores each product type needs: ceil(quantities[i] / x)
Sum up all required stores and check if it's <= n
Return the first x that works

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with x=1

Check if we can distribute with max 1 product per store

Try x=2

If x=1 failed, try x=2

Continue incrementing

Keep trying until we find a feasible maximum

Code -

solution.c — C

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

bool canDistribute(int n, int* quantities, int m, int maxProducts) {
    int storesNeeded = 0;
    for (int i = 0; i < m; i++) {
        storesNeeded += (quantities[i] + maxProducts - 1) / maxProducts;
        if (storesNeeded > n) {
            return false;
        }
    }
    return true;
}

int minimizedMaximum(int n, int* quantities, int m) {
    int maxQty = 0;
    for (int i = 0; i < m; i++) {
        if (quantities[i] > maxQty) {
            maxQty = quantities[i];
        }
    }
    
    for (int maxProducts = 1; maxProducts <= maxQty; maxProducts++) {
        if (canDistribute(n, quantities, m, maxProducts)) {
            return maxProducts;
        }
    }
    
    return maxQty;
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    int quantities[m];
    for (int i = 0; i < m; i++) {
        scanf("%d", &quantities[i]);
    }
    printf("%d\n", minimizedMaximum(n, quantities, m));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(quantities) * m)

We try each possible maximum value and for each one, we check all m product types

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for calculation

✓ Linear Space

Constraints

m == quantities.length
1 ≤ m ≤ n ≤ 10⁵
1 ≤ quantities[i] ≤ 10⁵
Key insight: We always have enough stores (n ≥ m)

52.0K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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 Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler