[Leetcode] 799. Champagne Tower 解题报告_leetcode champange tower recurusive-优快云博客

这篇博客详细介绍了LeetCode 799题——香槟塔的问题，阐述了如何利用动态规划求解。博主首先解释了问题背景，描述了香槟塔的构建方式和液体下落规则。接着，博主提出动态规划的思路，给出了递推公式，并指出了在计算过程中需要注意的两个细节。最后，虽然提供了完整的O(n^2)时间复杂度和空间复杂度的解决方案，但鼓励读者尝试使用滚动数组优化空间复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

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 (250ml) of champagne.

Then, some champagne is poured in the first glass at the top. When the top most 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. (A glass at the bottom row has it's excess champagne fall on the floor.)

For example, after one cup of champagne is poured, the top most 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. After four cups of champagne are poured, the third row has the middle glass half full, and the two outside glasses are a quarter full, as pictured below.

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

Example 1:
Input: poured = 1, query_glass = 1, query_row = 1
Output: 0.0
Explanation: We poured 1 cup of champange to the top glass of the tower (which is indexed as (0, 0)). There will be no excess liquid so all the glasses under the top glass will remain empty.

Example 2:
Input: poured = 2, query_glass = 1, query_row = 1
Output: 0.5
Explanation: We poured 2 cups of champange to the top glass of the tower (which is indexed as (0, 0)). There is one cup of excess liquid. The glass indexed as (1, 0) and the glass indexed as (1, 1) will share the excess liquid equally, and each will get half cup of champange.

Note:

poured will be in the range of [0, 10 ^ 9].
query_glass and query_row will be in the range of [0, 99].

思路：

我们定义dp[i][j]表示在加入poured杯的香槟之后，第i行第j个玻璃杯中的香槟量（不考虑溢出），那么通过观察可以得知递推公式为：dp[i][j] = (dp[i - 1][j - 1] - 1) / 2 + (dp[i - 1][j] - 1) / 2。这样就可以采用动态规划的方法得到dp[i][j]了。不过有两个地方需要特别注意：

1）当dp[i - 1][j - 1]和dp[i - 1][j]中的量都不满1杯的时候，它无法向外溢出，所以我们需要取dp[i - 1][j - 1] - 1和dp[i - 1][j] - 1与0.0的max值；

2）最终返回dp[i][j]的时候，需要考虑溢出，所以应该返回min(dp[i][j], 1.0)。

算法的时间复杂度是O(n^2)，空间复杂度也是O(n^2)。不过通过观察可以知道，dp[i][j]只和dp[i - 1][j - 1]与dp[i - 1][j]相关，因此，我们采用滚动数组，还可以进一步将空间复杂度降低到O(n)，留给读者自己优化吧^_^。

代码：

class Solution {
public:
    double champagneTower(int poured, int query_row, int query_glass) {
        vector<vector<double>> dp(100, vector<double>());
        dp[0].push_back(poured);
        for (int i = 1; i <= query_row; ++i) {
            double value = max(dp[i - 1][0] - 1, 0.0) / 2;
            dp[i].push_back(value);
            for (int j = 1; j <= i; ++j) {
                value = max(dp[i - 1][j - 1] - 1, 0.0) / 2;
                dp[i].push_back(value);
                value = max(dp[i - 1][j] - 1, 0.0) / 2;
                dp[i][j] += value;
            }
        }
        return min(dp[query_row][query_glass], 1.0);
    }
};