Maximum Profit of Operating a Centennial Wheel - Problem

Array Simulation Medium

You are the operator of a Centennial Wheel that has four gondolas, and each gondola has room for up to four people. You have the ability to rotate the gondolas counterclockwise, which costs you runningCost dollars.

You are given an array customers of length n where customers[i] is the number of new customers arriving just before the i-th rotation (0-indexed). This means you must rotate the wheel i times before the customers[i] customers arrive. You cannot make customers wait if there is room in the gondola. Each customer pays boardingCost dollars when they board on the gondola closest to the ground and will exit once that gondola reaches the ground again.

You can stop the wheel at any time, including before serving all customers. If you decide to stop serving customers, all subsequent rotations are free in order to get all the customers down safely. Note that if there are currently more than four customers waiting at the wheel, only four will board the gondola, and the rest will wait for the next rotation.

Return the minimum number of rotations you need to perform to maximize your profit. If there is no scenario where the profit is positive, return -1.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Rotation 0: 4 customers board (4 wait), profit = 4*5-6 = 14. Rotation 1: 1+4=5 customers, 4 board (1 wait), profit = 14+4*5-6 = 28. Rotation 2: 1 customer boards, profit = 28+1*5-6 = 27. Rotation 3: 0 customers board, profit = 27+0*5-6 = 21. Maximum profit is 28 at rotation 1, but we need 3 more rotations for customers to exit, so return 3.

Example 2 — No Profit

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

› Output: 7

💡 Note: Each rotation can board max 4 customers earning 4*6=24, but costs 4, so net +20 per full rotation. Process all customers and additional rotations to maximize profit.

Example 3 — Unprofitable

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

› Output: -1

💡 Note: Maximum revenue per rotation is 4*1=4, but cost is 92, so every rotation loses money. No positive profit possible.

Constraints

1 ≤ customers.length ≤ 1000
0 ≤ customers[i] ≤ 50
1 ≤ boardingCost, runningCost ≤ 100

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18

The key insight is to simulate the wheel rotation step by step, tracking profit at each rotation. The optimal approach uses single-pass simulation to find the rotation with maximum profit in O(n) time.

Common Approaches

✓ Brute Force - Check All Stop Points

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

For each possible stopping point from 0 to total rotations needed, simulate the entire wheel operation and calculate the final profit. This involves checking every scenario exhaustively.

Single Pass Simulation

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

Simulate the wheel operation rotation by rotation, calculating profit incrementally. Track the maximum profit seen so far and the rotation where it occurred.

Brute Force - Check All Stop Points — Algorithm Steps

For each possible stop point
Simulate wheel operation up to that point
Calculate total profit
Track maximum profit and best rotation

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Stop 0

Calculate profit if we stop immediately

Try Stop 1

Calculate profit if we stop after 1 rotation

Best Result

Return rotation with maximum profit

Code -

solution.c — C

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

int solution(int* customers, int customersSize, int boardingCost, int runningCost) {
    int n = customersSize;
    int maxProfit = 0;
    int bestRotation = -1;
    
    // Try stopping at each possible rotation
    for (int stopAt = 0; stopAt < n + 4; stopAt++) {
        int waiting = 0;
        int profit = 0;
        
        for (int rotation = 0; rotation <= stopAt; rotation++) {
            if (rotation < n) {
                waiting += customers[rotation];
            }
            
            // Board customers (up to 4)
            int boarding = waiting < 4 ? waiting : 4;
            waiting -= boarding;
            
            // Collect revenue and pay cost
            profit += boarding * boardingCost - runningCost;
        }
        
        if (profit > maxProfit) {
            maxProfit = profit;
            bestRotation = stopAt;
        }
    }
    
    // If we found a profitable solution, add 3 more rotations for customers to exit
    if (maxProfit > 0) {
        return bestRotation + 3;
    }
    return -1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int customers[1000];
    int size = 0;
    char* token = strtok(line + 1, ",]"); // Skip opening bracket
    while (token != NULL) {
        customers[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int boardingCost, runningCost;
    scanf("%d", &boardingCost);
    scanf("%d", &runningCost);
    
    int result = solution(customers, size, boardingCost, runningCost);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n possible stop points, we simulate up to n rotations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Maximum Profit of Operating a Centennial Wheel - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Stop Points — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler