Minimize Maximum of Array

Minimize Maximum of Array - Problem

Array Binary Search Dynamic Programming Greedy Prefix Sum Medium

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.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,7,1,6]

› Output: 5

💡 Note: We can move values leftward: 7→6 (move 1 left), then distribute optimally to get maximum of 5

Example 2 — Already Optimal

$ Input: nums = [10,1]

› Output: 10

💡 Note: Cannot reduce the maximum since we can only move from right to left, and leftmost is already maximum

Example 3 — Equal Distribution

$ Input: nums = [4,9,7,4]

› Output: 6

💡 Note: Optimal redistribution gives us [6,6,6,6] with maximum 6

Constraints

n == nums.length
2 ≤ n ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15

The key insight is that we can only move values leftward, so we binary search on the minimum achievable maximum value. For each candidate maximum, we simulate the redistribution process to check feasibility. The optimal approach uses binary search on the answer space with O(n log(sum)) time complexity.

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(n × log(sum)) Space: O(1)

Binary search on the answer space (minimum possible maximum). For each candidate maximum, check if it's achievable by simulating the operations.

Brute Force Simulation

⏱️ Time: O(n × sum²) Space: O(1)

Simulate the process by repeatedly finding operations that reduce the maximum value. Continue until no beneficial moves exist.

Prefix Sum Approach

⏱️ Time: O(n²) Space: O(n)

Use prefix sums to determine how values can be redistributed. For each position, calculate if the average distribution up to that point would be beneficial.

Binary Search on Answer — Algorithm Steps

Set search range from 0 to max(nums)
For each candidate maximum, simulate operations
Check if we can achieve that maximum
Narrow search based on feasibility

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Space

Range from 0 to sum of all elements

Check Feasibility

For each candidate max, simulate if achievable

Narrow Range

Binary search finds the minimum achievable maximum

Code -

solution.c — C

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

int canAchieve(int* nums, int size, long long maxVal) {
    long long* arr = (long long*)malloc(size * sizeof(long long));
    for (int i = 0; i < size; i++) {
        arr[i] = nums[i];
    }
    
    for (int i = size - 1; i > 0; i--) {
        if (arr[i] > maxVal) {
            long long excess = arr[i] - maxVal;
            arr[i] = maxVal;
            arr[i - 1] += excess;
        }
    }
    int result = arr[0] <= maxVal;
    free(arr);
    return result;
}

int solution(int* nums, int size) {
    long long left = 0, right = 0;
    
    for (int i = 0; i < size; i++) {
        right += nums[i];
    }
    
    while (left < right) {
        long long mid = left + (right - left) / 2;
        if (canAchieve(nums, size, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return (int)left;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000], size = 0;
    parseArray(line, nums, &size);
    
    printf("%d\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log(sum))

Binary search O(log(sum)) iterations, each taking O(n) to validate

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for simulation

⚡ Linearithmic Space

32.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler