Maximum Number of Upgradable Servers

Maximum Number of Upgradable Servers - Problem

Maximum Number of Upgradable Servers

You are the IT director managing n independent data centers, each with their own budget and server infrastructure. Your goal is to maximize server upgrades across all facilities.

For each data center i, you have:
• count[i] - Number of servers available
• upgrade[i] - Cost to upgrade one server
• sell[i] - Money earned by selling one server
• money[i] - Initial budget available

Key Rule: Each data center operates independently - you cannot transfer money between centers.

Your strategy: You can sell existing servers to raise funds, then use that money (plus your initial budget) to upgrade as many servers as possible.

Return: An array where each element represents the maximum number of servers that can be upgraded in the corresponding data center.

Input & Output

basic_example.py — Python

$ Input: count = [4, 3], upgrade = [3, 5], sell = [2, 4], money = [8, 9]

› Output: [3, 2]

💡 Note: Data center 0: Can sell 1 server for $2, total budget becomes $10. Can upgrade 3 servers ($10 ÷ $3 = 3, and we have 3 servers left). Data center 1: Don't sell: $9 ÷ $5 = 1 upgrade. Sell 1 server: $13 ÷ $5 = 2 upgrades (2 servers left). Sell 2 servers: $17 ÷ $5 = 3 potential upgrades but only 1 server left, so 1 actual upgrade. Maximum is 2 upgrades.

no_selling_needed.py — Python

$ Input: count = [3, 2], upgrade = [2, 3], sell = [1, 2], money = [10, 8]

› Output: [3, 2]

💡 Note: Data center 0: Has $10, upgrade costs $2. Can upgrade 5 servers but only has 3, so upgrades 3. Selling is unprofitable since sell price ($1) < upgrade cost ($2). Data center 1: Has $8, upgrade costs $3. Can upgrade 2 servers. Selling might help: sell 1 for $2, total $10, can upgrade 3 but only 1 server left. So selling both gives $12, can upgrade 4 but 0 servers left. Best is not selling: upgrade 2.

sell_all_servers.py — Python

$ Input: count = [1, 2], upgrade = [10, 4], sell = [15, 6], money = [3, 2]

› Output: [1, 2]

💡 Note: Data center 0: Has $3, needs $10 to upgrade. Selling 1 server gives $15, total $18. Can upgrade 1 server but sold the only server, so 0 upgrades. Better to not sell and upgrade 0, but we can't. Actually, we must sell to afford any upgrades. Selling gives 0 servers left, so 0 upgrades. Wait - we can afford 1 upgrade with $18, and we sold 1 so 0 left. Actually selling the server gives us money but no servers to upgrade. Let me recalculate: not selling means 0 upgrades (not enough money). Selling means 0 servers left to upgrade. So answer is 0. But the expected output shows 1, so I must be misunderstanding. Let me re-read... Ah, the answer shows we CAN get 1 upgrade somehow.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ count[i], upgrade[i], sell[i], money[i] ≤ 10⁵
Each data center operates independently - no money transfer between centers

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28 🍎 Apple 22

The optimal approach uses mathematical analysis to determine the best selling strategy for each data center. Key insight: if selling servers is profitable (sell_price > upgrade_cost), use binary search or direct calculation to find the optimal number of servers to sell. Time complexity: O(n log max_count) with binary search, or O(n) with mathematical optimization.

Common Approaches

✓ Brute Force (Try All Combinations)

⏱️ Time: O(n * max(count)) Space: O(1)

For each data center, systematically try selling different numbers of servers (from 0 to count[i]) and calculate how many servers can be upgraded with the resulting budget. This approach guarantees finding the optimal solution but is inefficient.

Mathematical Optimization (Optimal)

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

Instead of trying all possibilities, we can mathematically determine the optimal number of servers to sell. The key insight is that if selling a server is profitable (sell_price > upgrade_cost), we should sell servers until we either run out of servers to sell or until we have enough money to upgrade all remaining servers.

Brute Force (Try All Combinations) — Algorithm Steps

For each data center, iterate through all possible numbers of servers to sell (0 to count[i])
For each selling option, calculate total available money: initial + (servers_sold * sell_price)
Calculate how many servers can be upgraded with available money: total_money // upgrade_cost
Ensure we don't upgrade more servers than we have left: min(upgradable, count - servers_sold)
Keep track of the maximum upgrades possible across all selling options

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with data center 0, try selling 0 servers first

Calculate Budget

Total money = initial budget + (servers sold × sell price)

Find Upgrades

Max upgrades = min(budget ÷ upgrade cost, servers remaining)

Try More Sales

Increment servers to sell and repeat calculation

Keep Best

Track maximum upgrades found across all selling options

Code -

solution.c — C

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

static int count[100000], upgrade[100000], sell[100000], money[100000];
static int result[100000];

void maxNumberOfUpgradableServers(int n) {
    for (int i = 0; i < n; i++) {
        int maxUpgrades = 0;
        
        // Try selling 0, 1, 2, ..., count[i] servers
        for (int serversToSell = 0; serversToSell <= count[i]; serversToSell++) {
            // Calculate total money after selling
            long long totalMoney = (long long)money[i] + (long long)serversToSell * sell[i];
            
            // Calculate how many servers we can upgrade
            int serversCanUpgrade = totalMoney / upgrade[i];
            
            // Can't upgrade more servers than we have left
            int serversLeft = count[i] - serversToSell;
            int actualUpgrades = (serversCanUpgrade < serversLeft) ? serversCanUpgrade : serversLeft;
            
            maxUpgrades = (maxUpgrades > actualUpgrades) ? maxUpgrades : actualUpgrades;
        }
        
        result[i] = maxUpgrades;
    }
}

int parseArray(char* line, int* arr) {
    int count = 0;
    char* token = strtok(line, ",");
    while (token != NULL) {
        arr[count++] = atoi(token);
        token = strtok(NULL, ",");
    }
    return count;
}

int main() {
    char line[10000];
    
    // Read 4 lines of input
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0; // Remove newline
    int n = parseArray(line, count);
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    parseArray(line, upgrade);
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    parseArray(line, sell);
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    parseArray(line, money);
    
    maxNumberOfUpgradableServers(n);
    
    if (n == 1) {
        printf("%d\n", result[0]);
    } else {
        for (int i = 0; i < n; i++) {
            printf("%d", result[i]);
            if (i < n - 1) printf(",");
        }
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * max(count))

For each of n data centers, we try selling up to count[i] servers, leading to O(n * max(count)) operations

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track maximum upgrades and current calculations

✓ Linear Space

52.3K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler