Maximum Profit of Operating a Centennial Wheel

Maximum Profit of Operating a Centennial Wheel - Problem

Array Simulation Medium

Maximum Profit of Operating a Centennial Wheel

You're the operator of a Centennial Wheel (a large ferris wheel) with 4 gondolas, where each gondola can hold up to 4 customers. The wheel rotates counterclockwise, and each rotation costs you runningCost dollars.

Given an array customers where customers[i] represents new customers arriving just before the i-th rotation, you must decide the optimal number of rotations to maximize profit. Each customer pays boardingCost when boarding and exits when their gondola returns to the ground.

Key Rules:
• You must rotate i times before customers[i] arrive
• Maximum 4 customers can board per rotation (excess customers wait)
• You can stop operating at any time
• After stopping, remaining rotations to bring customers down are free

Goal: Return the minimum rotations needed to achieve maximum profit, or -1 if no positive profit is possible.

Input & Output

example_1.py — Basic Case

$ Input: customers = [8,3], boardingCost = 5, runningCost = 6

› Output: 3

💡 Note: Rotation 1: 4 customers board (4 waiting), profit = 4×5 - 1×6 = 14. Rotation 2: 4 more customers board (3 still waiting), profit = 8×5 - 2×6 = 28. Rotation 3: 3 remaining customers board, profit = 11×5 - 3×6 = 37. This is the maximum profit achievable.

example_2.py — Unprofitable Case

$ Input: customers = [10,9,6], boardingCost = 6, runningCost = 4

› Output: 7

💡 Note: Even though there are many customers, we need to find the optimal stopping point. After serving all customers across multiple rotations, rotation 7 gives the maximum profit.

example_3.py — No Profit Case

$ Input: customers = [3,4,0,5,1], boardingCost = 1, runningCost = 92

› Output: -1

💡 Note: Since the running cost (92) is much higher than the maximum possible revenue per rotation (4×1=4), it's impossible to make a profit regardless of how many customers we serve.

Constraints

n == customers.length
1 ≤ n ≤ 10⁵
0 ≤ customers[i] ≤ 50
1 ≤ boardingCost, runningCost ≤ 100
Each gondola holds exactly 4 customers
Customers must be served in arrival order

Visualization

Tap to expand

Understanding the Visualization

Customers Arrive

New customers join the waiting queue before each rotation

Board & Rotate

Up to 4 customers board, wheel rotates (costs money)

Calculate Profit

Revenue from boarding minus rotation costs

Track Maximum

Remember the best profit and when it occurred

Optimal Stop

Return the rotation count that maximized profit

Key Takeaway

🎯 Key Insight: Single-pass simulation with profit tracking eliminates the need for multiple expensive simulations, achieving optimal O(n) time complexity.

Asked in

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

The optimal solution uses single-pass simulation to track profit at each rotation. Key insight: we don't need multiple simulations - just track the maximum profit and corresponding rotation during one pass. The algorithm handles customer queuing, boarding limits, and profit calculation efficiently in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Simulation (Optimal)	O(n)	O(1)	Simulate the wheel once, tracking maximum profit during the process
Brute Force (Multiple Simulations)	O(n²)	O(1)	Try every possible stopping point by running complete simulations

Single Pass Simulation (Optimal) — Algorithm Steps

Initialize variables: waiting customers, total served, current profit
For each rotation, add new arriving customers to waiting queue
Board up to 4 customers from the waiting queue
Update profit: add boarding revenue, subtract running cost
Track maximum profit seen so far and corresponding rotation
Continue until no more customers arrive and queue is empty
Return rotation count with maximum profit

Visualization

Tap to expand

Step-by-Step Walkthrough

Rotation 1

Process customers[0], update profit, track max

Rotation 2

Process customers[1], update profit, track max

Continue

Keep going until all customers served

Code -

solution.c — C

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

int minOperationsMaxProfit(int* customers, int n, int boardingCost, int runningCost) {
    // Early optimization: if max revenue per rotation < cost, impossible
    if (boardingCost * 4 <= runningCost) {
        return -1;
    }
    
    int waiting = 0;
    int totalCustomers = 0;
    int currentProfit = 0;
    int maxProfit = 0;
    int bestRotation = -1;
    int rotation = 0;
    
    // Process all arriving customers
    for (int i = 0; i < n; i++) {
        waiting += customers[i];
        rotation++;
        
        // Board up to 4 customers
        int boarding = (waiting < 4) ? waiting : 4;
        waiting -= boarding;
        totalCustomers += boarding;
        
        // Update profit
        currentProfit = totalCustomers * boardingCost - rotation * runningCost;
        
        if (currentProfit > maxProfit) {
            maxProfit = currentProfit;
            bestRotation = rotation;
        }
    }
    
    // Continue serving remaining waiting customers
    while (waiting > 0) {
        rotation++;
        int boarding = (waiting < 4) ? waiting : 4;
        waiting -= boarding;
        totalCustomers += boarding;
        
        currentProfit = totalCustomers * boardingCost - rotation * runningCost;
        
        if (currentProfit > maxProfit) {
            maxProfit = currentProfit;
            bestRotation = rotation;
        }
    }
    
    return bestRotation;
}

int main() {
    // Input parsing implementation
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through customers array, plus at most n additional rotations to serve remaining customers

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for tracking variables

✓ Linear Space

28.7K Views

Medium Frequency

~18 min Avg. Time

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

Single Pass Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler