3155. Maximum Number of Upgradable Servers 🔒

Problem Description

You have n data centers and need to upgrade their servers. For each data center, you are provided with four arrays of length n: count, upgrade, sell, and money. These arrays illustrate the following for each data center:

count[i]: The number of servers available.
upgrade[i]: The cost required to upgrade a single server.
sell[i]: The money received by selling a single server.
money[i]: The initial amount of money you have.

Your task is to determine the maximum number of servers that can be upgraded in each data center. The solution should be an array answer, with each element representing the maximum number of servers that can be upgraded in the corresponding data center. Note that financial resources cannot be transferred between data centers.

Quick Interview Experience

Help others by sharing your interview experience

Have you seen this problem before?

Intuition

The primary aim is to determine the number of servers, x, that can be upgraded in each data center. To achieve this, the total cost of upgrading x servers must be less than or equal to the total funds available. This includes not only the initial money but also the potential returns from selling servers. Thus, for data center i:

Calculate total funds available as count[i] * sell[i] + money[i], which includes the money received from selling all servers plus any additional given money.
To upgrade x servers, you need x * upgrade[i] money.
From the inequality x * upgrade[i] <= count[i] * sell[i] + money[i], solve for x. It should satisfy x <= (count[i] * sell[i] + money[i]) / (upgrade[i] + sell[i]).
Additionally, x cannot exceed the total number of servers count[i], hence x is the minimum of the two values: count[i] and (count[i] * sell[i] + money[i]) / (upgrade[i] + sell[i]).

By applying this logic to each data center, we can deduce the maximum number of upgradable servers.

Learn more about Math and Binary Search patterns.

Solution Approach

The approach to solve this problem involves a straightforward application of mathematical inequalities to determine how many servers can be upgraded in each data center. The solution iterates over each data center, evaluates the maximum upgradable servers based on available resources, and stores the result in the answer array. Here's a step-by-step breakdown:

Iterate Over Data Centers:
- Use a loop to process each data center's information. This involves iterating over the arrays count, upgrade, sell, and money simultaneously using zip.
Calculate Maximum Upgradable Servers:
- For each data center, calculate the maximum servers x that can be upgraded by considering both the upgrade cost and the potential return from selling. This is done using the formula:
  
  [ x = \min \left(\text{count[i]}, \frac{\text{count[i]} \times \text{sell[i]} + \text{money[i]}}{\text{upgrade[i]} + \text{sell[i]}}\right) ]
- This formula considers the lesser of the total servers available or the number derived from the financial constraint involving upgrade costs and selling proceeds.
Store the Result:
- Append the calculated maximum value of x to the ans list, representing how many servers can be upgraded at that respective data center.
Output the Results:
- After processing all data centers, return the ans list, which holds the maximum number of upgradable servers for each data center.

The solution effectively utilizes basic mathematical operations and list traversal while ensuring each computation respects the constraints on resources for each data center individually.

Ready to land your dream job?

Unlock your dream job with a 3-minute evaluator for a personalized learning plan!

Start Evaluator

Example Walkthrough

Let's consider a simplified example where you have n = 2 data centers. The arrays are defined as follows:

count = [4, 5]: Data center 1 has 4 servers, and data center 2 has 5 servers.
upgrade = [10, 20]: Upgrading a server costs 10 in data center 1 and 20 in data center 2.
sell = [5, 3]: Selling a server yields 5 in data center 1 and 3 in data center 2.
money = [15, 40]: You have 15 at data center 1 and 40 at data center 2 initially.

Let's walk through the solution step-by-step:

Iterate Over Data Centers:
- Data Center 1:
  - Available funds from selling all servers: 4 * 5 = 20.
  - Total funds available: 20 + 15 = 35.
  - Calculate maximum x using the formula:
    
    [ x = \min \left(4, \frac{4 \times 5 + 15}{10 + 5} \right) = \min \left(4, \frac{35}{15}\right) = \min(4, 2.333) = 2 ]
  - You can upgrade a maximum of 2 servers in data center 1.
- Data Center 2:
  - Available funds from selling all servers: 5 * 3 = 15.
  - Total funds available: 15 + 40 = 55.
  - Calculate maximum x using the formula:
    
    [ x = \min \left(5, \frac{5 \times 3 + 40}{20 + 3} \right) = \min \left(5, \frac{55}{23}\right) = \min(5, 2.391) = 2 ]
  - You can upgrade a maximum of 2 servers in data center 2.
Store the Result:
- Append the calculated maximum values to the answer list: ans = [2, 2].
Output the Results:
- The final result is [2, 2], signifying that you can upgrade 2 servers in each data center, considering the costs, potential gains from selling, and initial funds.

This approach effectively evaluates each data center independently, ensuring optimal use of resources without cross-utilization between centers.

Solution Implementation

1from typing import List
2
3class Solution:
4    def maxUpgrades(
5        self, count: List[int], upgrade: List[int], sell: List[int], money: List[int]
6    ) -> List[int]:
7        # Initialize the result list to store the maximum upgrades for each scenario.
8        ans = []
9
10        # Iterate over the elements of the input lists simultaneously using zip.
11        for cnt, cost, income, cash in zip(count, upgrade, sell, money):
12            # Calculate the maximum number of upgrades possible without exceeding budget.
13            # This is decided by the constraints: 
14            # 1. Not exceeding the available items (cnt).
15            # 2. Keeping within the budget which is (cnt * income + cash).
16            # The cost per upgrade is (cost + income).
17            max_upgrades = min(cnt, (cnt * income + cash) // (cost + income))
18
19            # Append the result for the current scenario to the answer list.
20            ans.append(max_upgrades)
21
22        # Return the list of results after processing all scenarios.
23        return ans
24

1class Solution {
2    public int[] maxUpgrades(int[] count, int[] upgrade, int[] sell, int[] money) {
3        int n = count.length; // Get the number of items
4      
5        int[] ans = new int[n]; // Initialize an array to store the maximum upgrades for each item
6      
7        for (int i = 0; i < n; ++i) {
8            // Calculate the maximum number of upgrades possible for the current item
9            // 'count[i]' is the number of items, 'sell[i]' is the selling price per item
10            // 'money[i]' is the initial amount of money we have
11            // 'upgrade[i]' is the cost required to upgrade one item
12            ans[i] = Math.min(
13                count[i], 
14                (int) ((1L * count[i] * sell[i] + money[i]) / (upgrade[i] + sell[i]))
15            );
16        }
17
18        return ans; // Return the array of maximum upgrades for each item
19    }
20}
21

1class Solution {
2public:
3    // Function to calculate the maximum number of upgrades possible for each item
4    vector<int> maxUpgrades(vector<int>& count, vector<int>& upgrade, vector<int>& sell, vector<int>& money) {
5        int n = count.size(); // Total number of different items
6        vector<int> ans; // Vector to store results for each item
7
8        for (int i = 0; i < n; ++i) {
9            // Calculate the maximum possible upgrades for item i
10            // Calculate the total available money by selling all items plus given money
11            // Divide this by the cost to upgrade one item plus the selling price of one item
12            // Use min to ensure the number of upgrades does not exceed the available count
13            int max_possible_upgrades = min(count[i], 
14                static_cast<int>((1LL * count[i] * sell[i] + money[i]) / (upgrade[i] + sell[i]))
15            );
16          
17            // Add the result for the current item to the answer vector
18            ans.push_back(max_possible_upgrades);
19        }
20
21        return ans; // Return the vector containing the possible upgrades for each item
22    }
23};
24

1// Function to calculate the maximum number of upgrades for a given list of items
2function maxUpgrades(
3    count: number[],  // Array representing the initial count of items
4    upgrade: number[], // Array representing the cost to upgrade each item
5    sell: number[], // Array representing the selling price of each item
6    money: number[], // Array representing additional money available for each item
7): number[] {
8    const n: number = count.length; // Total number of items
9    const result: number[] = []; // Array to store the result of maximum upgrades for each item
10
11    for (let i = 0; i < n; ++i) {
12        // Calculate the maximum number of upgrades possible for the i-th item
13        const maxPossibleUpgrades: number = Math.floor((count[i] * sell[i] + money[i]) / (upgrade[i] + sell[i]));
14        // Store the minimum between the calculated upgrades and the current item count
15        result.push(Math.min(maxPossibleUpgrades, count[i]));
16    }
17
18    return result; // Return the array of maximum upgrades for each item
19}
20

Time and Space Complexity

The time complexity is O(n), where n is the length of the array. This is because the function iterates over the lists count, upgrade, sell, and money, each containing n elements, in a single loop.

The space complexity is O(1), excluding the space used by the input and output lists. The space complexity is determined by the auxiliary space used, which is constant since variables like cnt, cost, income, and cash are used to store elements from the input lists one at a time.

Learn more about how to find time and space complexity quickly.

Discover Your Strengths and Weaknesses: Take Our 3-Minute Quiz to Tailor Your Study Plan:

Is the following code DFS or BFS?

void search(Node root) {
  if (!root) return;
  visit(root);
  root.visited = true;
  for (Node node in root.adjacent) {
    if (!node.visited) {
      search(node);
    }
  }
}

Depth First Search

Breadth First Search

I don't know