2064. Minimized Maximum of Products Distributed to Any Store

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 ith 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 be 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.

 Example 1:

Input: n = 6, quantities = [11,6]
Output: 3
Explanation: One optimal way is:
- The 11 products of type 0 are distributed to the first four stores in these amounts: 2, 3, 3, 3
- The 6 products of type 1 are distributed to the other two stores in these amounts: 3, 3
The maximum number of products given to any store is max(2, 3, 3, 3, 3, 3) = 3.

Example 2:

Input: n = 7, quantities = [15,10,10]
Output: 5
Explanation: One optimal way is:
- The 15 products of type 0 are distributed to the first three stores in these amounts: 5, 5, 5
- The 10 products of type 1 are distributed to the next two stores in these amounts: 5, 5
- The 10 products of type 2 are distributed to the last two stores in these amounts: 5, 5
The maximum number of products given to any store is max(5, 5, 5, 5, 5, 5, 5) = 5.

Example 3:

Input: n = 1, quantities = [100000]
Output: 100000
Explanation: The only optimal way is:
- The 100000 products of type 0 are distributed to the only store.
The maximum number of products given to any store is max(100000) = 100000.

 Constraints:

• m == quantities.length
• 1 <= m <= n <= 105
• 1 <= quantities[i] <= 105

C++

// Time: O(QlogM) where `Q` is the length of `quantities` and `M` is the max element in `quantities`.
// Space: O(1)
class Solution {
public:
    int minimizedMaximum(int n, vector<int>& Q) {
        long long L = 1, R = accumulate(begin(Q), end(Q), 0LL);
        auto valid = [&](int M) {
            int ans = 0;
            for (int n : Q) ans += (n + M - 1) / M; // ceil(n / M)
            return ans <= n;
        };
        while (L <= R) {
            long long M = (L + R) / 2;
            if (valid(M)) R = M - 1;
            else L = M + 1;
        }
        return L;
    }
};

• class Solution {
      public int minimizedMaximum(int n, int[] quantities) {
          int left = 1, right = (int) 1e5;
          while (left < right) {
              int mid = (left + right) >> 1;
              int cnt = 0;
              for (int v : quantities) {
                  cnt += (v + mid - 1) / mid;
              }
              if (cnt <= n) {
                  right = mid;
              } else {
                  left = mid + 1;
              }
          }
          return left;
      }
  }

JAVA

• class Solution {
      public int minimizedMaximum(int n, int[] quantities) {
          int left = 1, right = (int) 1e5;
          while (left < right) {
              int mid = (left + right) >> 1;
              int cnt = 0;
              for (int v : quantities) {
                  cnt += (v + mid - 1) / mid;
              }
              if (cnt <= n) {
                  right = mid;
              } else {
                  left = mid + 1;
              }
          }
          return left;
      }
  }

• class Solution {
      public int minimizedMaximum(int n, int[] quantities) {
          int left = 1, right = (int) 1e5;
          while (left < right) {
              int mid = (left + right) >> 1;
              int cnt = 0;
              for (int v : quantities) {
                  cnt += (v + mid - 1) / mid;
              }
              if (cnt <= n) {
                  right = mid;
              } else {
                  left = mid + 1;
              }
          }
          return left;
      }
  }

PYTHON

from math import ceil
from functools import reduce

class Solution:
    def minimizedMaximum(self, n, quantities):
        def is_valid(max_items):
            return sum(ceil(q / max_items) for q in quantities) <= n

        left, right = 1, sum(quantities)
        while left <= right:
            mid = (left + right) // 2
            if is_valid(mid):
                right = mid - 1
            else:
                left = mid + 1
        
        return left