贪心算法解决柠檬水找零问题

1. 问题背景与需求分析

柠檬水找零问题是一个经典的贪心算法练习题，题目描述如下：假设你经营一家柠檬水摊，每杯柠檬水售价5美元。顾客排队购买，每次只买一杯柠檬水，并支付5美元、10美元或20美元。你必须正确找零（注意：一开始你手头没有任何零钱）。给定一个整数数组bills，其中bills[i]是第i位顾客支付的金额，如果你能给每位顾客正确找零，返回true，否则返回false。

这个问题的核心在于如何高效管理手头的零钱，并在面对不同面额的支付时做出最优的找零决策。作为一道LeetCode中等难度题目，它很好地考察了程序员对贪心算法的理解和实际应用能力。

2. 解题思路与算法选择

2.1 贪心算法原理

贪心算法是一种在每一步选择中都采取当前状态下最优的选择，从而希望导致全局最优解的算法策略。对于找零问题，贪心算法特别适用，因为美元的面额设计本身就具有贪心性质 - 即较大的面额是较小面额的整数倍。

在本题中，当收到20美元时，我们优先使用10美元+5美元的组合找零（而不是三张5美元），因为这样可以保留更多的5美元零钱，为后续可能需要的找零做准备。这就是贪心策略的体现。

2.2 具体解题步骤

1. 初始化三个计数器，分别记录5美元、10美元和20美元的数量（虽然20美元不需要找零，但统计它有助于理解整个流程）
2. 遍历顾客支付序列：
   • 收到5美元：直接收下，5美元计数器加1
   • 收到10美元：检查是否有至少一张5美元，如果有则找零，10美元计数器加1
   • 收到20美元：优先使用10+5的组合找零（更优），如果没有10美元则使用三张5美元
3. 如果在任何时候无法满足找零需求，立即返回false
4. 如果所有顾客都能正确找零，最后返回true

3. 代码实现与详细解析

3.1 数据结构选择

我们使用一个长度为3的数组ch来记录各面额的数量：

• ch[0]：5美元数量
• ch[1]：10美元数量
• ch[2]：20美元数量

选择数组而不是三个独立变量的好处是代码更简洁，且便于可能的扩展（如果未来面额种类增加）。

3.2 完整代码实现

cpp复制class Solution {
public:
    int ch[3] = {0, 0, 0}; // 分别记录5、10、20的数量
    
    bool lemonadeChange(vector<int>& bills) {
        for(int bill : bills) {
            if(bill == 5) {
                ch[0]++; // 直接收下5美元
            } 
            else if(bill == 10) {
                if(ch[0] == 0) return false; // 没有5美元可找
                ch[0]--; // 找零一张5美元
                ch[1]++; // 收下10美元
            } 
            else { // 处理20美元
                // 优先使用10+5的组合找零
                if(ch[1] > 0 && ch[0] > 0) {
                    ch[1]--;
                    ch[0]--;
                } 
                // 没有10美元，尝试用三张5美元
                else if(ch[0] >= 3) {
                    ch[0] -= 3;
                } 
                // 两种找零方式都不行
                else {
                    return false;
                }
                ch[2]++; // 收下20美元（虽然不影响找零逻辑）
            }
        }
        return true;
    }
};

3.3 关键逻辑解析

1. 10美元处理：

   • 必须有一张5美元才能找零
   • 如果没有立即返回false

2. 20美元处理：

   • 优先检查是否有10+5的组合（这是贪心策略的关键）
   • 如果没有，再检查是否有三张5美元
   • 两种方式都不满足时返回false

3. 边界条件：

   • 空输入：直接返回true（没有顾客自然不需要找零）
   • 第一个顾客支付20美元：直接返回false（没有零钱可找）

4. 复杂度分析与优化

4.1 时间复杂度

• 只需要一次遍历整个账单数组，时间复杂度为O(n)，其中n是bills的长度
• 每个账单的处理都是常数时间操作（比较和增减计数器）

4.2 空间复杂度

• 只使用了固定大小的额外空间（3个int的数组）
• 空间复杂度为O(1)

4.3 可能的优化

虽然当前实现已经很高效，但还可以做以下微优化：

1. 去掉20美元的计数器（因为20美元不需要用于找零）
2. 使用两个独立变量five和ten代替数组，可能减少索引开销
3. 在遍历过程中一旦发现无法找零立即返回，避免不必要的继续检查

优化后的代码如下：

cpp复制class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int five = 0, ten = 0;
        for(int bill : bills) {
            if(bill == 5) {
                five++;
            } else if(bill == 10) {
                if(five == 0) return false;
                five--;
                ten++;
            } else {
                if(ten > 0 && five > 0) {
                    ten--;
                    five--;
                } else if(five >= 3) {
                    five -= 3;
                } else {
                    return false;
                }
            }
        }
        return true;
    }
};

5. 常见错误与调试技巧

5.1 常见错误类型

1. 贪心策略错误：

   • 在处理20美元时没有优先使用10+5的组合
   • 错误地总是使用三张5美元找零，导致后续10美元无法找零

2. 边界条件遗漏：

   • 忘记处理第一个顾客就支付20美元的情况
   • 没有考虑连续多个顾客支付大额钞票的情况

3. 状态更新错误：

   • 找零后忘记更新钞票计数器
   • 错误地增加了不应该增加的钞票计数

5.2 调试技巧

1. 小规模测试用例：

   • [5,5,10] → true
   • [10,10] → false
   • [5,5,10,20] → true
   • [5,5,10,10,20] → false

2. 打印中间状态：
   在每次处理账单后打印当前各面额的数量，帮助追踪问题：

cpp复制cout << "After " << bill << ": five=" << five << ", ten=" << ten << endl;

3. 极端情况测试：
   • 空数组
   • 全部是5美元
   • 交替出现10美元和20美元

6. 实际应用与扩展

6.1 现实中的应用

虽然题目设定是柠檬水摊，但类似的找零问题在以下场景都很常见：

• 零售收银系统
• 自动售货机
• 公共交通售票系统

理解这个算法有助于设计更健壮的支付找零逻辑。

6.2 问题变种与扩展

1. 更多面额：

   • 如果增加50美元、100美元等面额，算法如何调整？
   • 需要制定更复杂但类似的贪心策略

2. 有限零钱：

   • 初始时有一定数量的零钱，而非完全为零
   • 需要修改初始条件

3. 最优找零：

   • 不只是能否找零，而是找出需要最少钞票数量的找零方案
   • 可能需要动态规划来解决

6.3 类似题目推荐

1. LeetCode 322. Coin Change
2. LeetCode 518. Coin Change 2
3. LeetCode 1029. Two City Scheduling（另一种贪心算法应用）

7. 个人经验与心得

在实际编码面试中，这类问题考察的不仅是算法实现能力，更重要的是：

1. 沟通能力：先解释思路再写代码
2. 边界意识：主动考虑各种边界情况
3. 代码整洁：良好的变量命名和结构
4. 优化意识：写完基本解法后讨论优化空间

我在最初解决这个问题时，曾犯过没有优先使用10+5组合的错误。后来通过以下测试用例发现了问题：

输入：[5,5,10,10,20]
错误解法返回：true（实际应为false）

这个案例教会我在实现贪心算法时，一定要仔细验证"贪心选择"的正确性。有时候看起来合理的局部最优，不一定导致全局最优。