Champagne Tower

Champagne Tower - Problem

Dynamic Programming Medium

We stack glasses in a pyramid, where the first row has 1 glass, the second row has 2 glasses, and so on until the 100th row. Each glass holds one cup of champagne.

Then, some champagne is poured into the first glass at the top. When the topmost glass is full, any excess liquid poured will fall equally to the glass immediately to the left and right of it. When those glasses become full, any excess champagne will fall equally to the left and right of those glasses, and so on.

For example, after one cup of champagne is poured, the topmost glass is full. After two cups of champagne are poured, the two glasses on the second row are half full. After three cups of champagne are poured, those two cups become full - there are 3 full glasses total now.

Now after pouring some non-negative integer cups of champagne, return how full the jth glass in the ith row is (both i and j are 0-indexed).

Input & Output

Example 1 — Two Cups Poured

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

› Output: 0.5

💡 Note: Pour 2 cups into top glass: glass[0][0] gets 1.0 (full), remaining 1.0 overflows equally to row 1. Each glass in row 1 gets 0.5.

Example 2 — One Cup Only

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

› Output: 0.0

💡 Note: Only 1 cup poured fills the top glass completely. No overflow reaches row 1, so glass[1][1] remains empty.

Example 3 — Large Pour

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

› Output: 1.0

💡 Note: With 100 million cups, champagne fills many levels completely. Glass at row 33, position 17 will be completely full.

Constraints

0 ≤ poured ≤ 10⁹
0 ≤ query_glass ≤ query_row < 100

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 M Microsoft 6

The key insight is to simulate the champagne pouring process level by level, where overflow from each glass splits equally between the two glasses directly below it. The simulation approach creates a 2D tower array and processes overflow row by row until reaching the target. Best approach is the space-optimized version that only tracks current and next rows. Time: O(n²), Space: O(n) for optimized version.

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Optimized Row Processing

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

Instead of storing the entire tower, we only keep track of the current row and next row. This optimizes space while maintaining the same logic of overflow distribution.

Simulation Approach

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

Create a 2D array representing the champagne tower. Start by pouring all champagne into the top glass, then simulate the overflow process level by level until we reach the target row.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static double tower[101][101];

double champagneTower(int poured, int query_row, int query_glass) {
    // Initialize tower
    for (int i = 0; i <= 100; i++) {
        for (int j = 0; j <= 100; j++) {
            tower[i][j] = 0.0;
        }
    }
    
    // Pour champagne into the top glass
    tower[0][0] = (double)poured;
    
    // Simulate the flow
    for (int row = 0; row < query_row; row++) {
        for (int col = 0; col <= row; col++) {
            if (tower[row][col] > 1.0) {
                double excess = tower[row][col] - 1.0;
                double half_excess = excess / 2.0;
                
                // Flow to left child
                tower[row + 1][col] += half_excess;
                // Flow to right child
                tower[row + 1][col + 1] += half_excess;
                
                // Current glass becomes full
                tower[row][col] = 1.0;
            }
        }
    }
    
    // Return how full the queried glass is (capped at 1.0)
    if (tower[query_row][query_glass] > 1.0) {
        return 1.0;
    }
    return tower[query_row][query_glass];
}

int main() {
    int poured, query_row, query_glass;
    
    scanf("%d", &poured);
    scanf("%d", &query_row);
    scanf("%d", &query_glass);
    
    double result = champagneTower(poured, query_row, query_glass);
    
    printf("%.1f\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

125.0K Views

Medium Frequency

~25 min Avg. Time

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