Maximum Total Area Occupied by Pistons

Maximum Total Area Occupied by Pistons - Problem

Array Hash Table String Simulation Counting Prefix Sum Hard

There are several pistons in an old car engine, and we want to calculate the maximum possible area under the pistons.

You are given:

An integer height, representing the maximum height a piston can reach.
An integer array positions, where positions[i] is the current position of piston i, which is equal to the current area under it.
A string directions, where directions[i] is the current moving direction of piston i, 'U' for up, and 'D' for down.

Each second:

Every piston moves in its current direction 1 unit. e.g., if the direction is up, positions[i] is incremented by 1.
If a piston has reached one of the ends, i.e., positions[i] == 0 or positions[i] == height, its direction will change.

Return the maximum possible area under all the pistons.

Input & Output

Example 1 — Basic Case

$ Input: height = 4, positions = [1,3,2], directions = "UDU"

› Output: 9

💡 Note: At time 3: piston 1 reaches position 4 (up from 1), piston 2 reaches position 2 (down from 3, hit 0, bounced up), piston 3 reaches position 3 (up from 2, hit 4, bounced down). Total area = 4+2+3 = 9

Example 2 — All Moving Up

$ Input: height = 3, positions = [1,2], directions = "UU"

› Output: 5

💡 Note: Both pistons move up. At time 1: positions become [2,3], total = 5. At time 2: piston 2 bounces and becomes [3,2], total = 5. Maximum area is 5

Example 3 — Single Piston

$ Input: height = 5, positions = [2], directions = "D"

› Output: 5

💡 Note: Piston moves down to 0, then up to maximum height 5. Maximum area is 5 when it reaches the top

Constraints

1 ≤ height ≤ 10⁵
1 ≤ positions.length ≤ 10⁴
0 ≤ positions[i] ≤ height
directions.length == positions.length
directions[i] is either 'U' or 'D'

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is that pistons follow predictable cycles. The simulation approach tracks movement step-by-step, while the mathematical approach calculates positions directly using cycle analysis. Best approach is mathematical analysis with Time: O(n × height), Space: O(1).

Common Approaches

✓ Mathematical Analysis

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

Each piston follows a predictable pattern based on its starting position and direction. Instead of simulating, we calculate when each piston reaches its maximum possible contribution and find the optimal alignment.

Simulation

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

Track each piston's position and direction, updating them every second. Record the maximum total area seen so far. Continue until we detect a cycle or reach a reasonable time limit.

Mathematical Analysis — Algorithm Steps

Step 1: Calculate cycle time for each piston
Step 2: Find all possible times when pistons reach peak values
Step 3: Evaluate total area at critical time points

Visualization

Tap to expand

Step-by-Step Walkthrough

Analyze Cycles

Each piston follows a 2×height cycle pattern

Calculate Positions

Use math to find position at any time t

Find Maximum

Check all critical time points in one cycle

Code -

solution.c — C

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

int solution(int height, int* positions, int posSize, char* directions) {
    int* pos = malloc(posSize * sizeof(int));
    char* dirs = malloc((posSize + 1) * sizeof(char));
    
    for (int i = 0; i < posSize; i++) {
        pos[i] = positions[i];
        dirs[i] = directions[i];
    }
    dirs[posSize] = '\0';
    
    int maxArea = 0;
    for (int i = 0; i < posSize; i++) {
        maxArea += pos[i];
    }
    
    // Simulate until cycle detected (limited iterations for safety)
    for (int t = 0; t < 100000; t++) {
        for (int i = 0; i < posSize; i++) {
            if (dirs[i] == 'U') {
                pos[i]++;
                if (pos[i] == height) dirs[i] = 'D';
            } else {
                pos[i]--;
                if (pos[i] == 0) dirs[i] = 'U';
            }
        }
        
        int sum = 0;
        for (int i = 0; i < posSize; i++) {
            sum += pos[i];
        }
        if (sum > maxArea) maxArea = sum;
    }
    
    free(pos);
    free(dirs);
    return maxArea;
}

int main() {
    int height;
    scanf("%d", &height);
    
    char line[1000];
    scanf(" %s", line);
    
    // Parse array manually
    int positions[100];
    int posSize = 0;
    char* ptr = line + 1; // skip '['
    while (*ptr != ']') {
        if (*ptr == ',' || *ptr == '[') ptr++;
        positions[posSize++] = atoi(ptr);
        while (*ptr != ',' && *ptr != ']') ptr++;
    }
    
    char directions[101];
    scanf("%s", directions);
    
    int result = solution(height, positions, posSize, directions);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × height)

For each piston, analyze its cycle pattern which depends on height

✓ Linear Growth

Space Complexity

O(1)

Only storing mathematical calculations, no extra arrays

✓ Linear Space

28.4K Views

Medium Frequency

~35 min Avg. Time

892 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

Mathematical Analysis — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler