Maximum Profit of Operating a Centennial Wheel

• Initialize state variables: waitingCustomers = 0, currentProfit = 0, maxProfit = 0, rotations = 0, resultRotations = -1, and an index i = 0 for the customers array.
• Use a single while loop that continues as long as there are new customers to process (i < customers.length) or there are customers waiting in line (waitingCustomers > 0).
• In each iteration, which represents one rotation:
  • Increment the rotations counter.
  • If i is within the bounds of the customers array, add the new customers (customers[i]) to waitingCustomers and increment i.
  • Determine the number of customers to board: boarded = min(waitingCustomers, 4).
  • Update waitingCustomers by subtracting boarded.
  • Calculate the profit for this rotation and add it to currentProfit: currentProfit += boarded * boardingCost - runningCost.
  • If currentProfit is greater than maxProfit, update maxProfit = currentProfit and resultRotations = rotations.
• After the loop terminates, return resultRotations. If profit never became positive, maxProfit would remain 0 and resultRotations would remain -1.

We use a single while loop that continues as long as there are customers arriving (we haven't processed the whole customers array) or there are people waiting in line. Inside the loop, each iteration represents one rotation of the wheel.

1. We increment the rotation count.
2. If there are new customers scheduled to arrive for this rotation (i.e., we haven't exhausted the customers array), we add them to the waitingCustomers count.
3. We determine how many customers can board in this rotation, which is the minimum of the number of waiting customers and the capacity of a gondola (4).
4. We update the number of waitingCustomers by subtracting those who just boarded.
5. We calculate the profit for this rotation (boarded * boardingCost - runningCost) and add it to our currentProfit.
6. We then check if this currentProfit is greater than the maxProfit found so far. If it is, we update maxProfit and store the current number of rotations.
7. The loop terminates when all customers from the input array have arrived and the waiting line is empty.
8. Finally, we return the number of rotations that yielded the maximum profit. If the maximum profit was never positive, we return -1.

We use long for profit variables to prevent potential integer overflow.

1class Solution {2    public int minOperationsMaxProfit(int[] customers, int boardingCost, int runningCost) {3        long waitingCustomers = 0;4        long currentProfit = 0;5        long maxProfit = 0; // Start with 0, as we only care about positive profit6        int rotations = 0;7        int resultRotations = -1;8        int i = 0;9 10        while (i < customers.length || waitingCustomers > 0) {11            rotations++;12            if (i < customers.length) {13                waitingCustomers += customers[i];14                i++;15            }16 17            long board = Math.min(waitingCustomers, 4);18            waitingCustomers -= board;19 20            currentProfit += board * boardingCost - runningCost;21 22            if (currentProfit > maxProfit) {23                maxProfit = currentProfit;24                resultRotations = rotations;25            }26        }27 28        return resultRotations;29    }30}

• Initialize state variables: waitingCustomers = 0, currentProfit = 0, maxProfit = 0, rotations = 0, resultRotations = -1.
• Phase 1: Simulation during arrivals.
  • Loop through the customers array. For each entry customers[i], simulate one rotation.
  • Increment rotations, add customers[i] to waitingCustomers.
  • Board up to 4 customers, update waitingCustomers and currentProfit.
  • Check if currentProfit is a new maxProfit and update if necessary.
• Phase 2: Post-processing for remaining customers.
  • After the loop, check if waitingCustomers > 0.
  • Calculate the profit for a full rotation: profitPerFour = 4 * boardingCost - runningCost.
  • If profitPerFour <= 0, it's not profitable to continue, so we stop.
  • If profitPerFour > 0:
    • Calculate the number of full rotations for the remaining customers: fullRotations = waitingCustomers / 4.
    • Add the bulk profit fullRotations * profitPerFour to currentProfit and fullRotations to rotations.
    • Check for a new maxProfit.
    • Calculate the remaining customers after full rotations: remaining = waitingCustomers % 4.
    • If remaining > 0, simulate one final rotation for them, update currentProfit and rotations, and perform a final check for maxProfit.
• Return resultRotations.

The simulation is split into two phases:

1. Initial Phase (during customer arrivals): We iterate through the customers array. In each iteration, we simulate one rotation, adding new customers, boarding up to 4, and updating the profit. We track the maximum profit throughout this phase.

2. Post-processing Phase (after all arrivals): After the initial loop, we might have waitingCustomers left. Instead of looping, we calculate the profit from them analytically.

   • First, we determine if it's even profitable to continue. The best-case profit per rotation is 4 * boardingCost - runningCost. If this value is not positive, we stop.
   • If it is profitable, we calculate how many full rotations (boarding 4 customers) we can do with the waitingCustomers. We compute the total profit and rotations from these in one step.
   • We then check if this new profit state gives us a new maximum.
   • Finally, we handle the last few remaining customers (fewer than 4) with one final rotation and profit calculation, again checking if it results in a new maximum profit.

This two-phase approach is more efficient as it replaces a potentially long loop with a few constant-time arithmetic operations.

1class Solution {2    public int minOperationsMaxProfit(int[] customers, int boardingCost, int runningCost) {3        long waitingCustomers = 0;4        long currentProfit = 0;5        long maxProfit = 0;6        int rotations = 0;7        int resultRotations = -1;8 9        // Phase 1: Process customers as they arrive10        for (int customerCount : customers) {11            rotations++;12            waitingCustomers += customerCount;13            14            long board = Math.min(waitingCustomers, 4);15            waitingCustomers -= board;16            17            currentProfit += board * boardingCost - runningCost;18            19            if (currentProfit > maxProfit) {20                maxProfit = currentProfit;21                resultRotations = rotations;22            }23        }24 25        // Phase 2: Process remaining waiting customers26        if (waitingCustomers > 0) {27            long profitPerFour = (long)4 * boardingCost - runningCost;28            29            if (profitPerFour > 0) {30                long fullRotations = waitingCustomers / 4;31                currentProfit += fullRotations * profitPerFour;32                rotations += fullRotations;33                34                if (currentProfit > maxProfit) {35                    maxProfit = currentProfit;36                    resultRotations = rotations;37                }38                39                long remainingCustomers = waitingCustomers % 4;40                if (remainingCustomers > 0) {41                    long lastProfit = remainingCustomers * boardingCost - runningCost;42                    currentProfit += lastProfit;43                    rotations++;44                    if (currentProfit > maxProfit) {45                        maxProfit = currentProfit;46                        resultRotations = rotations;47                    }48                }49            }50        }51        52        return resultRotations;53    }54}