Minimize Maximum of Array - Practice Coding Problems

Minimize Maximum of Array - Problem

Array Binary Search Dynamic Programming Greedy Prefix Sum Medium

Minimize Maximum of Array is a fascinating optimization problem that challenges you to redistribute array elements strategically.

You're given a 0-indexed array nums containing n non-negative integers. Your goal is to minimize the maximum value in the array by performing a special redistribution operation.

The Operation:
• Choose an index i where 1 ≤ i < n and nums[i] > 0
• Decrease nums[i] by 1
• Increase nums[i-1] by 1

You can perform this operation any number of times. The key insight is that you can only move values leftward in the array - from any position to its left neighbor.

Example: For array [3,7,1,6], you can transform it to [5,5,4,4] where the maximum is 5, which is optimal.

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

Input & Output

example_1.py — Basic Case

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

› Output: 5

💡 Note: We can perform operations: [3,7,1,6] → [5,5,1,6] → [5,5,2,5] → [5,5,3,4] → [5,5,4,3] giving us a maximum of 5.

example_2.py — Already Optimal

$ Input: [10,1]

› Output: 10

💡 Note: The array is already optimal. We cannot move the value from index 0 to any position, so the maximum remains 10.

example_3.py — Single Element

$ Input: [5]

› Output: 5

💡 Note: With only one element, no operations are possible, so the maximum remains 5.

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
Key insight: You can only move values leftward (from index i to i-1)

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Start with towers of different heights

Transfer Water

Move water from any tower to its immediate left neighbor

Optimize Heights

Continue until the tallest tower is minimized

Key Takeaway

🎯 Key Insight: Binary search on the answer with prefix sum validation gives us O(n log max_value) optimal solution

Asked in

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

The optimal solution uses binary search on the answer combined with prefix sum validation. Key insight: since we can only move values leftward, we can check if a target maximum is achievable by ensuring no prefix sum exceeds target × positions. Time complexity: O(n log max_value).

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(n² × max_value)	O(1)	Repeatedly perform operations until no beneficial moves remain
Binary Search + Prefix Sum (Optimal)	O(n log(max_value))	O(1)	Binary search on the answer with prefix sum validation

Simulation Approach — Algorithm Steps

Find the current maximum value and its position
Try to move values leftward from positions that have the maximum value
Repeat until no more beneficial operations can be performed
Return the final maximum value

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Maximum

Identify positions with maximum values

Try Redistribution

Move values leftward if beneficial

Repeat

Continue until no beneficial moves remain

Code -

solution.c — C

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

int findMax(int* nums, int n) {
    int max = nums[0];
    for (int i = 1; i < n; i++) {
        if (nums[i] > max) max = nums[i];
    }
    return max;
}

int minimizeArrayValue(int* nums, int n) {
    int changed = 1;
    
    while (changed) {
        changed = 0;
        int maxVal = findMax(nums, n);
        
        for (int i = 1; i < n; i++) {
            if (nums[i] > 0 && nums[i] == maxVal) {
                if (nums[i] > (nums[i] + nums[i-1]) / 2) {
                    nums[i]--;
                    nums[i-1]++;
                    changed = 1;
                    break;
                }
            }
        }
    }
    
    return findMax(nums, n);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[100];
    int n = 0;
    char* token = strtok(input, "[],");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%d\n", minimizeArrayValue(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × max_value)

In worst case, we might need to perform max_value operations for each of the n positions

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler