Maximum Number of Robots Within Budget

Maximum Number of Robots Within Budget - Problem

Array Binary Search Queue Sliding Window Heap (Priority Queue) Prefix Sum Monotonic Queue Hard

You are the manager of a robotic manufacturing plant and need to optimize the operation of your robots within a limited budget. You have n robots available, each with different charging and operational costs.

Given two arrays:

chargeTimes[i] - the cost to charge the i-th robot
runningCosts[i] - the ongoing operational cost per unit time for the i-th robot

The total cost of running k consecutive robots is calculated as:

Total Cost = max(chargeTimes) + k × sum(runningCosts)

Where max(chargeTimes) is the highest charging cost among the selected robots, and sum(runningCosts) is the sum of all operational costs.

Goal: Find the maximum number of consecutive robots you can operate without exceeding your budget.

Input & Output

example_1.py — Basic Case

$ Input: chargeTimes = [3,6,1,3,4], runningCosts = [2,1,3,4,5], budget = 25

› Output: 3

💡 Note: We can run robots [1,2,3] with charge times [6,1,3] and running costs [1,3,4]. Total cost = max(6,1,3) + 3×(1+3+4) = 6 + 24 = 30 > budget. Let's try [0,1,2]: max(3,6,1) + 3×(2+1+3) = 6 + 18 = 24 ≤ 25. We can run 3 consecutive robots.

example_2.py — Small Budget

$ Input: chargeTimes = [11,12,19], runningCosts = [10,8,7], budget = 19

› Output: 0

💡 Note: Even running a single robot costs at least 11 + 1×10 = 21 > 19, so we cannot run any robots within the budget.

example_3.py — Large Budget

$ Input: chargeTimes = [1,1,1,1], runningCosts = [1,1,1,1], budget = 50

› Output: 4

💡 Note: We can run all robots. Total cost = max(1,1,1,1) + 4×(1+1+1+1) = 1 + 16 = 17 ≤ 50. All 4 consecutive robots can be operated.

Constraints

1 ≤ chargeTimes.length == runningCosts.length ≤ 5 × 10⁴
1 ≤ chargeTimes[i], runningCosts[i] ≤ 10⁵
1 ≤ budget ≤ 10¹⁵
All robots must be consecutive in the array

Visualization

Tap to expand

Asked in

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

The optimal solution uses a sliding window approach with monotonic deque to efficiently track the maximum charge cost. We expand the window when possible and contract when over budget, achieving O(n) time complexity. The key insight is that each element enters and leaves the deque at most once, making the solution highly efficient.

Common Approaches

✓ Binary Search on Answer

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

Since if we can run k robots, we can also run any number less than k, we can binary search on the answer. For each candidate answer, use sliding window to check if it's achievable within budget.

Brute Force (Check All Subarrays)

⏱️ Time: O(n³) Space: O(1)

For each possible starting position, we extend the window as far as possible while staying within budget. We calculate the cost using the maximum charge time in the current window plus the sum of running costs multiplied by window size.

Sliding Window with Two Pointers

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

Use two pointers to maintain a sliding window. Expand the right pointer to include more robots when possible, and contract the left pointer when the cost exceeds the budget. Use a deque to efficiently track the maximum charge time in the current window.

Binary Search on Answer — Algorithm Steps

Set binary search bounds: left=0, right=n
For each mid value, check if we can run mid consecutive robots
Use sliding window to find if any window of size mid fits budget
Adjust search bounds based on feasibility
Return the maximum feasible value

Visualization

Tap to expand

Step-by-Step Walkthrough

Set search space

left=0, right=n (maximum possible robots)

Test middle value

Can we run mid consecutive robots?

Validate with sliding window

Check all windows of size mid

Adjust search bounds

Update left/right based on feasibility

Code -

solution.c — C

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

static int chargeTimes[50000];
static int runningCosts[50000];
static int maxDeque[50000];

bool canRunKRobots(int k, int n, long long budget) {
    if (k == 0) return true;
    if (k > n) return false;
    
    long long runningSum = 0;
    int front = 0, back = -1;
    
    // Initialize first window of size k
    for (int i = 0; i < k; i++) {
        runningSum += runningCosts[i];
        while (front <= back && chargeTimes[maxDeque[back]] <= chargeTimes[i]) {
            back--;
        }
        maxDeque[++back] = i;
    }
    
    // Check first window
    long long maxCharge = chargeTimes[maxDeque[front]];
    if (maxCharge + (long long)k * runningSum <= budget) {
        return true;
    }
    
    // Slide the window
    for (int right = k; right < n; right++) {
        int left = right - k + 1;
        
        // Add new element
        runningSum += runningCosts[right];
        while (front <= back && chargeTimes[maxDeque[back]] <= chargeTimes[right]) {
            back--;
        }
        maxDeque[++back] = right;
        
        // Remove old element
        runningSum -= runningCosts[left - 1];
        if (front <= back && maxDeque[front] == left - 1) {
            front++;
        }
        
        // Check current window
        if (front <= back) {
            maxCharge = chargeTimes[maxDeque[front]];
            if (maxCharge + (long long)k * runningSum <= budget) {
                return true;
            }
        }
    }
    
    return false;
}

int maximumRobots(int n, long long budget) {
    int left = 0, right = n;
    int result = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canRunKRobots(mid, n, budget)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int parseArray(char* str, int* arr) {
    if (strcmp(str, "") == 0 || strcmp(str, "[]") == 0) {
        return 0;
    }
    
    int count = 0;
    char* token = strtok(str, ",");
    while (token != NULL) {
        arr[count++] = (int)strtol(token, NULL, 10);
        token = strtok(NULL, ",");
    }
    return count;
}

int main() {
    char chargeTimesStr[200000], runningCostsStr[200000];
    long long budget;
    
    fgets(chargeTimesStr, sizeof(chargeTimesStr), stdin);
    fgets(runningCostsStr, sizeof(runningCostsStr), stdin);
    scanf("%lld", &budget);
    
    // Remove newlines
    chargeTimesStr[strcspn(chargeTimesStr, "\n")] = 0;
    runningCostsStr[strcspn(runningCostsStr, "\n")] = 0;
    
    int n1 = parseArray(chargeTimesStr, chargeTimes);
    int n2 = parseArray(runningCostsStr, runningCosts);
    
    int result = maximumRobots(n1, budget);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(log n) binary search iterations, each taking O(n) time for sliding window check

⚠ Quadratic Growth

Space Complexity

O(n)

Space for deque in sliding window validation

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

845 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