Maximize the Minimum Powered City - Practice Coding Problems

Maximize the Minimum Powered City - Problem

Array Binary Search Greedy Queue Sliding Window Prefix Sum Hard

Imagine you're an urban planner tasked with optimizing the power grid distribution across n cities arranged in a line. Each city currently has some number of power stations, given in the array stations[i].

Here's the key: each power station has a fixed range r, meaning a station in city i can provide power to all cities j where |i - j| <= r. The power of a city is the total number of stations that can reach it.

The government has approved funding for k additional power stations that you can place strategically in any cities. Your goal is to maximize the minimum power across all cities - essentially, you want to ensure even the least-powered city has as much power as possible.

Example: If stations = [1,2,4,5,0], r = 1, and k = 2, you need to determine the optimal placement of 2 new stations to maximize the minimum power any city receives.

Input & Output

example_1.py — Basic Case

$ Input: stations = [1,2,4,5,0], r = 1, k = 2

› Output: 5

💡 Note: Initially: City powers are [4,8,11,9,5] (each city gets power from stations within range r=1). The minimum is 4. We can place 2 additional stations optimally to achieve minimum power of 5.

example_2.py — Small Range

$ Input: stations = [4,4,4,4], r = 0, k = 3

› Output: 4

💡 Note: With r=0, each station only powers its own city. All cities start with power 4. Even with 3 additional stations, we can't increase the minimum beyond 4 by optimal placement.

example_3.py — Large Range

$ Input: stations = [1,1], r = 2, k = 10

› Output: 11

💡 Note: With r=2, both cities receive power from all stations. Initially both have power 2. With 10 additional stations placed optimally, both cities can reach power 11.

Visualization

Tap to expand

Understanding the Visualization

Calculate Initial Power

Use sliding window to compute each city's power from existing stations

Binary Search Setup

Search space from 0 to sum(stations) + k for maximum achievable minimum

Greedy Validation

For each candidate minimum, greedily place stations as far right as possible

Optimal Placement

Rightmost placement maximizes coverage for future cities

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with greedy rightmost placement creates an optimal O(n log(sum+k)) solution that efficiently handles large inputs.

Time & Space Complexity

Time Complexity

⏱️

O(n log(sum + k))

Binary search runs log(sum+k) iterations, each validation takes O(n) time with sliding window

⚡ Linearithmic

Space Complexity

O(n)

Space for storing current power configuration and additional stations placed

⚡ Linearithmic Space

Constraints

n == stations.length
1 ≤ n ≤ 10⁵
0 ≤ stations[i] ≤ 10⁵
0 ≤ r ≤ n - 1
0 ≤ k ≤ 10⁹
Large k values require efficient O(n log n) solution

Asked in

G Google 12 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal approach uses binary search on the answer combined with a greedy validation strategy. We binary search on the minimum power level we want to achieve, and for each candidate value, we greedily check if it's achievable with k additional stations by placing them as far right as possible in each city's range. This achieves O(n log(sum + k)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Greedy (Optimal)	O(n log(sum + k))	O(n)	Binary search on answer with greedy validation using sliding window
Brute Force (Try All Combinations)	O(n^k × n × r)	O(n)	Try all possible ways to place k additional stations

Binary Search + Greedy (Optimal) — Algorithm Steps

Calculate initial power for each city using sliding window/prefix sum
Binary search on the minimum power (left=0, right=sum+k)
For each mid value, greedily check if achievable with k stations
Place stations as far right as possible in each city's range to maximize coverage
Use sliding window to efficiently update power as we place stations

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Binary Search

Set left=0, right=sum(stations)+k as search bounds

Test Mid Value

Check if we can achieve minimum power of mid using ≤k stations

Greedy Placement

Place stations as far right as possible for maximum coverage

Update Search Range

If feasible, search higher; if not, search lower

Code -

solution.c — C

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

int canAchieve(long long minPower, long long* power, int n, int r, int k) {
    long long* additional = (long long*)calloc(n, sizeof(long long));
    long long used = 0;
    long long addSum = 0;
    
    for (int i = 0; i < n; i++) {
        if (i + r < n) addSum += additional[i + r];
        if (i - r - 1 >= 0) addSum -= additional[i - r - 1];
        
        long long currentPower = power[i] + addSum;
        
        if (currentPower < minPower) {
            long long need = minPower - currentPower;
            if (used + need > k) {
                free(additional);
                return 0;
            }
            
            int pos = (n - 1 < i + r) ? n - 1 : i + r;
            additional[pos] += need;
            used += need;
            
            if (pos <= i + r) addSum += need;
        }
    }
    
    free(additional);
    return 1;
}

long long maximizeMinimumPower(int* stations, int stationsSize, int r, int k) {
    int n = stationsSize;
    long long* power = (long long*)malloc(n * sizeof(long long));
    
    // Calculate initial power using sliding window
    long long windowSum = 0;
    for (int i = 0; i <= (n - 1 < r ? n - 1 : r); i++) {
        windowSum += stations[i];
    }
    power[0] = windowSum;
    
    for (int i = 1; i < n; i++) {
        if (i + r < n) windowSum += stations[i + r];
        if (i - r - 1 >= 0) windowSum -= stations[i - r - 1];
        power[i] = windowSum;
    }
    
    long long total = 0;
    for (int i = 0; i < n; i++) {
        total += stations[i];
    }
    
    long long left = 0, right = total + k;
    long long result = 0;
    
    while (left <= right) {
        long long mid = left + (right - left) / 2;
        if (canAchieve(mid, power, n, r, k)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    free(power);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(sum + k))

Binary search runs log(sum+k) iterations, each validation takes O(n) time with sliding window

⚡ Linearithmic

Space Complexity

O(n)

Space for storing current power configuration and additional stations placed

⚡ Linearithmic Space

Constraints

n == stations.length
1 ≤ n ≤ 10⁵
0 ≤ stations[i] ≤ 10⁵
0 ≤ r ≤ n - 1
0 ≤ k ≤ 10⁹
Large k values require efficient O(n log n) solution

21.1K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search + Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler