+ problem 2439

Author: fruit-in

Problemset/2439-Minimize Maximum of Array/README.md

@@ -0,0 +1,70 @@
+# 2439. Minimize Maximum of Array
+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:
+<pre>
+<strong>Input:</strong> nums = [3,7,1,6]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong>
+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.
+</pre>
+
+#### Example 2:
+<pre>
+<strong>Input:</strong> nums = [10,1]
+<strong>Output:</strong> 10
+<strong>Explanation:</strong>
+It is optimal to leave nums as is, and since 10 is the maximum value, we return 10.
+</pre>
+
+#### Constraints:
+* `n == nums.length`
+* <code>2 <= n <= 10<sup>5</sup></code>
+* <code>0 <= nums[i] <= 10<sup>9</sup></code>
+
+## Solutions (Rust)
+
+### 1. Solution
+```Rust
+impl Solution {
+    pub fn minimize_array_value(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut lo = *nums.iter().min().unwrap() as i64;
+        let mut hi = *nums.iter().max().unwrap() as i64;
+
+        while lo < hi {
+            let m = (lo + hi) / 2;
+            let mut x = nums[n - 1] as i64;
+
+            for i in (1..n).rev() {
+                if x > m {
+                    x += nums[i - 1] as i64 - m;
+                } else {
+                    x = nums[i - 1] as i64;
+                }
+            }
+
+            if x > m {
+                lo = m + 1;
+            } else {
+                hi = m;
+            }
+        }
+
+        hi as i32
+    }
+}
+```

Problemset/2439-Minimize Maximum of Array/README_CN.md

@@ -0,0 +1,70 @@
+# 2439. 最小化数组中的最大值
+给你一个下标从 **0** 开始的数组 `nums` ，它含有 `n` 个非负整数。
+
+每一步操作中，你需要：
+
+* 选择一个满足 `1 <= i < n` 的整数 `i` ，且 `nums[i] > 0` 。
+* 将 `nums[i]` 减 1 。
+* 将 `nums[i - 1]` 加 1 。
+
+你可以对数组执行 **任意** 次上述操作，请你返回可以得到的 `nums` 数组中 **最大值** **最小** 为多少。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong> nums = [3,7,1,6]
+<strong>输出:</strong> 5
+<strong>解释:</strong>
+一串最优操作是：
+1. 选择 i = 1 ，nums 变为 [4,6,1,6] 。
+2. 选择 i = 3 ，nums 变为 [4,6,2,5] 。
+3. 选择 i = 1 ，nums 变为 [5,5,2,5] 。
+nums 中最大值为 5 。无法得到比 5 更小的最大值。
+所以我们返回 5 。
+</pre>
+
+#### 示例 2:
+<pre>
+<strong>输入:</strong> nums = [10,1]
+<strong>输出:</strong> 10
+<strong>解释:</strong>
+最优解是不改动 nums ，10 是最大值，所以返回 10 。
+</pre>
+
+#### 提示:
+* `n == nums.length`
+* <code>2 <= n <= 10<sup>5</sup></code>
+* <code>0 <= nums[i] <= 10<sup>9</sup></code>
+
+## 题解 (Rust)
+
+### 1. 题解
+```Rust
+impl Solution {
+    pub fn minimize_array_value(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut lo = *nums.iter().min().unwrap() as i64;
+        let mut hi = *nums.iter().max().unwrap() as i64;
+
+        while lo < hi {
+            let m = (lo + hi) / 2;
+            let mut x = nums[n - 1] as i64;
+
+            for i in (1..n).rev() {
+                if x > m {
+                    x += nums[i - 1] as i64 - m;
+                } else {
+                    x = nums[i - 1] as i64;
+                }
+            }
+
+            if x > m {
+                lo = m + 1;
+            } else {
+                hi = m;
+            }
+        }
+
+        hi as i32
+    }
+}
+```

Problemset/2439-Minimize Maximum of Array/Solution.rs

@@ -0,0 +1,28 @@
+impl Solution {
+    pub fn minimize_array_value(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut lo = *nums.iter().min().unwrap() as i64;
+        let mut hi = *nums.iter().max().unwrap() as i64;
+
+        while lo < hi {
+            let m = (lo + hi) / 2;
+            let mut x = nums[n - 1] as i64;
+
+            for i in (1..n).rev() {
+                if x > m {
+                    x += nums[i - 1] as i64 - m;
+                } else {
+                    x = nums[i - 1] as i64;
+                }
+            }
+
+            if x > m {
+                lo = m + 1;
+            } else {
+                hi = m;
+            }
+        }
+
+        hi as i32
+    }
+}

README.md

@@ -1434,6 +1434,7 @@
 [2433][2433l]|[Find The Original Array of Prefix Xor][2433]                                         |![rs]
 [2434][2434l]|[Using a Robot to Print the Lexicographically Smallest String][2434]                  |![rs]
 [2437][2437l]|[Number of Valid Clock Times][2437]                                                   |![py]
+[2439][2439l]|[Minimize Maximum of Array][2439]                                                     |![rs]
 [2441][2441l]|[Largest Positive Integer That Exists With Its Negative][2441]                        |![rs]
 [2442][2442l]|[Count Number of Distinct Integers After Reverse Operations][2442]                    |![py]
 [2443][2443l]|[Sum of Number and Its Reverse][2443]                                                 |![py]
@@ -2939,6 +2940,7 @@
 [2433]:Problemset/2433-Find%20The%20Original%20Array%20of%20Prefix%20Xor/README.md#2433-find-the-original-array-of-prefix-xor
 [2434]:Problemset/2434-Using%20a%20Robot%20to%20Print%20the%20Lexicographically%20Smallest%20String/README.md#2434-using-a-robot-to-print-the-lexicographically-smallest-string
 [2437]:Problemset/2437-Number%20of%20Valid%20Clock%20Times/README.md#2437-number-of-valid-clock-times
+[2439]:Problemset/2439-Minimize%20Maximum%20of%20Array/README.md#2439-minimize-maximum-of-array
 [2441]:Problemset/2441-Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative/README.md#2441-largest-positive-integer-that-exists-with-its-negative
 [2442]:Problemset/2442-Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations/README.md#2442-count-number-of-distinct-integers-after-reverse-operations
 [2443]:Problemset/2443-Sum%20of%20Number%20and%20Its%20Reverse/README.md#2443-sum-of-number-and-its-reverse
@@ -4443,6 +4445,7 @@
 [2433l]:https://leetcode.com/problems/find-the-original-array-of-prefix-xor/
 [2434l]:https://leetcode.com/problems/using-a-robot-to-print-the-lexicographically-smallest-string/
 [2437l]:https://leetcode.com/problems/number-of-valid-clock-times/
+[2439l]:https://leetcode.com/problems/minimize-maximum-of-array/
 [2441l]:https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/
 [2442l]:https://leetcode.com/problems/count-number-of-distinct-integers-after-reverse-operations/
 [2443l]:https://leetcode.com/problems/sum-of-number-and-its-reverse/

README_CN.md

@@ -1434,6 +1434,7 @@
 [2433][2433l]|[找出前缀异或的原始数组][2433]                            |![rs]
 [2434][2434l]|[使用机器人打印字典序最小的字符串][2434]                  |![rs]
 [2437][2437l]|[有效时间的数目][2437]                                    |![py]
+[2439][2439l]|[最小化数组中的最大值][2439]                              |![rs]
 [2441][2441l]|[与对应负数同时存在的最大正整数][2441]                    |![rs]
 [2442][2442l]|[反转之后不同整数的数目][2442]                            |![py]
 [2443][2443l]|[反转之后的数字和][2443]                                  |![py]
@@ -2939,6 +2940,7 @@
 [2433]:Problemset/2433-Find%20The%20Original%20Array%20of%20Prefix%20Xor/README_CN.md#2433-找出前缀异或的原始数组
 [2434]:Problemset/2434-Using%20a%20Robot%20to%20Print%20the%20Lexicographically%20Smallest%20String/README_CN.md#2434-使用机器人打印字典序最小的字符串
 [2437]:Problemset/2437-Number%20of%20Valid%20Clock%20Times/README_CN.md#2437-有效时间的数目
+[2439]:Problemset/2439-Minimize%20Maximum%20of%20Array/README_CN.md#2439-最小化数组中的最大值
 [2441]:Problemset/2441-Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative/README_CN.md#2441-与对应负数同时存在的最大正整数
 [2442]:Problemset/2442-Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations/README_CN.md#2442-反转之后不同整数的数目
 [2443]:Problemset/2443-Sum%20of%20Number%20and%20Its%20Reverse/README_CN.md#2443-反转之后的数字和
@@ -4443,6 +4445,7 @@
 [2433l]:https://leetcode.cn/problems/find-the-original-array-of-prefix-xor/
 [2434l]:https://leetcode.cn/problems/using-a-robot-to-print-the-lexicographically-smallest-string/
 [2437l]:https://leetcode.cn/problems/number-of-valid-clock-times/
+[2439l]:https://leetcode.cn/problems/minimize-maximum-of-array/
 [2441l]:https://leetcode.cn/problems/largest-positive-integer-that-exists-with-its-negative/
 [2442l]:https://leetcode.cn/problems/count-number-of-distinct-integers-after-reverse-operations/
 [2443l]:https://leetcode.cn/problems/sum-of-number-and-its-reverse/