Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2439.html

2439. Minimize Maximum of Array

• Difficulty: Medium.
• Related Topics: .
• Similar Questions: .

Problem

You are given a 0-indexed array nums comprising of n non-negative integers.

In one operation, you must:

• Choose an integer i such that 1 <= i < n and nums[i] > 0.
• Decrease nums[i] by 1.
• Increase nums[i - 1] by 1.

Return the minimum possible value of the maximum integer of nums after performing any number of operations.

  Example 1:

Input: nums = [3,7,1,6]
Output: 5
Explanation:
One set of optimal operations is as follows:
1. Choose i = 1, and nums becomes [4,6,1,6].
2. Choose i = 3, and nums becomes [4,6,2,5].
3. Choose i = 1, and nums becomes [5,5,2,5].
The maximum integer of nums is 5. It can be shown that the maximum number cannot be less than 5.
Therefore, we return 5.

Example 2:

Input: nums = [10,1]
Output: 10
Explanation:
It is optimal to leave nums as is, and since 10 is the maximum value, we return 10.

  Constraints:

• n == nums.length

• 2 <= n <= 10^5

• 0 <= nums[i] <= 10^9

Solution (Java, C++, Python)

• Java
• C++
• Python
• Go

• class Solution {
      private int[] nums;
  
      public int minimizeArrayValue(int[] nums) {
          this.nums = nums;
          int left = 0, right = max(nums);
          while (left < right) {
              int mid = (left + right) >> 1;
              if (check(mid)) {
                  right = mid;
              } else {
                  left = mid + 1;
              }
          }
          return left;
      }
  
      private boolean check(int mx) {
          long d = 0;
          for (int i = nums.length - 1; i > 0; --i) {
              d = Math.max(0, d + nums[i] - mx);
          }
          return nums[0] + d <= mx;
      }
  
      private int max(int[] nums) {
          int v = nums[0];
          for (int x : nums) {
              v = Math.max(v, x);
          }
          return v;
      }
  }
  

• class Solution {
  public:
      int minimizeArrayValue(vector<int>& nums) {
          int left = 0, right = *max_element(nums.begin(), nums.end());
          auto check = [&](int mx) {
              long d = 0;
              for (int i = nums.size() - 1; i; --i) {
                  d = max(0l, d + nums[i] - mx);
              }
              return nums[0] + d <= mx;
          };
          while (left < right) {
              int mid = (left + right) >> 1;
              if (check(mid)) right = mid;
              else left = mid + 1;
          }
          return left;
      }
  };
  

• class Solution:
      def minimizeArrayValue(self, nums: List[int]) -> int:
          def check(mx):
              d = 0
              for x in nums[:0:-1]:
                  d = max(0, d + x - mx)
              return nums[0] + d <= mx
  
          left, right = 0, max(nums)
          while left < right:
              mid = (left + right) >> 1
              if check(mid):
                  right = mid
              else:
                  left = mid + 1
          return left
  
  

• func minimizeArrayValue(nums []int) int {
  	left, right := 0, 0
  	for _, x := range nums {
  		right = max(right, x)
  	}
  	check := func(mx int) bool {
  		d := 0
  		for i := len(nums) - 1; i > 0; i-- {
  			d = max(0, nums[i]+d-mx)
  		}
  		return nums[0]+d <= mx
  	}
  	for left < right {
  		mid := (left + right) >> 1
  		if check(mid) {
  			right = mid
  		} else {
  			left = mid + 1
  		}
  	}
  	return left
  }
  
  func max(a, b int) int {
  	if a > b {
  		return a
  	}
  	return b
  }
  

Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).

All Problems

All Solutions