Glass Pyramid Water Flow - Problem

Advanced DP DP Simulation Hard

Water is poured into the top glass of a pyramid structure. When a glass becomes full, it overflows equally into the two glasses directly below it. Given the amount of water poured and the position of a specific glass, find how much water is in that glass.

The pyramid is structured such that:

Row 0 has 1 glass
Row 1 has 2 glasses
Row r has (r+1) glasses

Each glass has a capacity of 1.0 liter. When a glass overflows, the excess water is split equally between the two glasses below it.

Input:

poured: Amount of water poured (double)
query_row: Row of the target glass (integer)
query_glass: Column position in that row (integer)

Output:

Return the amount of water in the glass at position (query_row, query_glass).

Input & Output

Example 1 — Basic Water Flow

$ Input: poured = 1.0, query_row = 1, query_glass = 1

› Output: 0.0

💡 Note: Pour 1.0 liter into top glass. Top glass holds exactly 1.0, no overflow. Glasses in row 1 remain empty.

Example 2 — Overflow Distribution

$ Input: poured = 2.0, query_row = 1, query_glass = 1

› Output: 0.5

💡 Note: Pour 2.0 liters. Top glass holds 1.0, overflow 1.0 splits equally: 0.5 to each glass in row 1.

Example 3 — Deep Pyramid

$ Input: poured = 100000009.0, query_row = 33, query_glass = 17

› Output: 1.0

💡 Note: Massive amount of water ensures all glasses in upper rows are full. Glass at (33,17) will be completely full.

Constraints

0 ≤ poured ≤ 10⁹
0 ≤ query_row ≤ 99
0 ≤ query_glass ≤ query_row

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 A Amazon 22 F Facebook 18

The key insight is that water flows predictably row by row, with each glass receiving water from at most two parent glasses above. Best approach is Bottom-Up DP that processes the pyramid iteratively. Time: O(r²), Space: O(r²).

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(r²) Space: O(r²)

Create a 2D DP table where dp[r][c] represents water amount in glass at row r, column c. Fill the table row by row from top to bottom, calculating overflow for each glass.

Simulation with Recursion

⏱️ Time: O(r²) Space: O(r²)

For each glass, recursively calculate how much water flows into it from the glasses above. Use memoization to avoid recalculating the same glass multiple times.

Bottom-Up Dynamic Programming — Algorithm Steps

Step 1: Initialize 2D DP table with zeros
Step 2: Set top glass dp[0][0] = min(1.0, poured)
Step 3: For each row, calculate overflow to glasses below
Step 4: Return dp[query_row][query_glass]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create DP table, set dp[0][0] = poured

Process Rows

For each glass, calculate overflow to glasses below

Distribute Water

Split excess water equally between two glasses below

Get Result

Return dp[query_row][query_glass]

Code -

solution.c — C

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

double solution(double poured, int queryRow, int queryGlass) {
    // Allocate DP table
    double** dp = (double**)malloc((queryRow + 1) * sizeof(double*));
    for (int i = 0; i <= queryRow; i++) {
        dp[i] = (double*)calloc(i + 1, sizeof(double));
    }
    dp[0][0] = poured;
    
    // Fill DP table row by row
    for (int r = 0; r < queryRow; r++) {
        for (int c = 0; c <= r; c++) {
            if (dp[r][c] > 1.0) {
                double overflow = (dp[r][c] - 1.0) / 2.0;
                dp[r][c] = 1.0;
                // Pour overflow to glasses below
                if (r + 1 <= queryRow) {
                    dp[r + 1][c] += overflow;
                    if (c + 1 <= r + 1) {
                        dp[r + 1][c + 1] += overflow;
                    }
                }
            }
        }
    }
    
    double result = dp[queryRow][queryGlass] < 1.0 ? dp[queryRow][queryGlass] : 1.0;
    
    // Free memory
    for (int i = 0; i <= queryRow; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    double poured;
    int queryRow, queryGlass;
    scanf("%lf", &poured);
    scanf("%d", &queryRow);
    scanf("%d", &queryGlass);
    
    double result = solution(poured, queryRow, queryGlass);
    printf("%f\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(r²)

Process all glasses up to target row, total glasses ≈ r²

✓ Linear Growth

Space Complexity

O(r²)

2D DP table stores water amounts for all glasses in pyramid

✓ Linear Space

34.5K Views

Medium Frequency

~25 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

Glass Pyramid Water Flow - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler