Champagne Tower - Practice Coding Problems

Champagne Tower - Problem

Dynamic Programming Medium

Champagne Tower Problem

Imagine you're at an elegant celebration where champagne glasses are arranged in a beautiful pyramid formation. The setup is breathtaking: 1 glass at the top, 2 glasses in the second row, 3 glasses in the third row, and so on, creating a perfect triangular tower up to 100 rows.

🥂 The Physics: When champagne is poured into the topmost glass, it follows the laws of gravity and overflow. Once a glass becomes completely full (holds exactly 1 cup), any additional champagne splits equally between the two glasses directly below it - one to the left diagonal and one to the right diagonal.

🎯 Your Mission: Given that poured cups of champagne are poured into the top glass, determine how full the glass at position (queryRow, queryGlass) is. The result should be a decimal between 0.0 (empty) and 1.0 (completely full).

Input: Three integers - poured (amount of champagne), queryRow and queryGlass (both 0-indexed)
Output: A decimal representing how full the specified glass is (clamped between 0.0 and 1.0)

Input & Output

example_1.py — Basic Overflow

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

› Output: 0.00000

💡 Note: With only 1 cup poured, the top glass becomes full (1.0) but has no overflow. The glasses in row 1 remain empty.

example_2.py — Equal Distribution

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

› Output: 0.50000

💡 Note: The top glass holds 1.0, and the remaining 1.0 cup splits equally between the two glasses in row 1. Each gets 0.5.

example_3.py — Multiple Level Overflow

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

› Output: 1.00000

💡 Note: With an enormous amount of champagne, virtually all glasses in the pyramid become completely full (1.0).

Constraints

0 ≤ poured ≤ 10⁹
0 ≤ query_row, query_glass ≤ 99
query_glass ≤ query_row
All inputs are integers except poured can be float
Answer within 10^-5 of actual answer is accepted

Visualization

Tap to expand

Understanding the Visualization

🍾 Initial Pour

All champagne starts in the topmost glass

💧 Overflow Check

If a glass holds more than 1.0, it overflows

⚖️ Equal Split

Excess champagne splits equally between two glasses below

🔄 Level Processing

Process entire level before moving to next

🎯 Target Reached

Return the amount in our target glass

Key Takeaway

🎯 Key Insight: Model the natural physics - champagne flows from top to bottom, level by level. Each glass holds at most 1.0 units, and excess splits equally between its two children below. Process complete levels sequentially for optimal efficiency.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18 Apple 15

The optimal solution uses dynamic programming simulation to model the natural champagne flow. Start with all champagne in the top glass, then process each level completely before moving to the next. For each overflowing glass (amount > 1.0), split the excess equally between its two children below. This approach achieves O(R²) time complexity where R is the query row, making it efficient even for the maximum constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive Simulation)	O(2^n)	O(n)	Recursively trace each unit of champagne from top to the target glass
Dynamic Programming Simulation (Optimal)	O(R²)	O(R)	Simulate the flow level by level using dynamic programming

Brute Force (Recursive Simulation) — Algorithm Steps

For each unit of champagne poured, start from the top glass (0,0)
If current glass is our target, return the amount that reaches it
If current glass can hold the champagne (< 1.0), store it and return
Otherwise, split the overflow equally between two glasses below
Recursively calculate for both left and right child glasses
Sum up contributions from all units of champagne

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Top

Begin with all champagne at glass (0,0)

Check Capacity

If glass can hold it all, stop. Otherwise, calculate overflow

Split Overflow

Divide excess equally between left and right children

Recurse Down

Repeat process for each child glass

Combine Results

Sum up all champagne reaching the target glass

Code -

solution.c — C

#include <stdio.h>
#include <math.h>

double dfs(double poured, int row, int glass, int queryRow, int queryGlass) {
    if (row > queryRow || glass < 0 || glass > row) {
        return 0.0;
    }
    if (row == queryRow && glass == queryGlass) {
        return fmin(1.0, poured);
    }
    if (poured <= 1.0) {
        return 0.0;
    }
    
    double overflow = (poured - 1.0) / 2.0;
    return dfs(overflow, row + 1, glass, queryRow, queryGlass) + 
           dfs(overflow, row + 1, glass + 1, queryRow, queryGlass);
}

double champagneTower(double poured, int queryRow, int queryGlass) {
    return fmin(1.0, dfs(poured, 0, 0, queryRow, queryGlass));
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, each unit of champagne could split exponentially down the pyramid

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth proportional to the number of rows

⚡ Linearithmic Space

42.6K Views

Medium Frequency

~25 min Avg. Time

1.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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Recursive Simulation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler