用C++解决百鸡问题：从古代数学到编程实战（附CCF-GESP考试真题解析）

用C++解决百鸡问题：从古代数学到编程实战（附CCF-GESP考试真题解析）

在数学与编程的交汇处，总有一些经典问题能够穿越时空，激发不同时代学习者的思考热情。百鸡问题正是这样一个绝佳案例——它诞生于1500多年前的中国古代算经，却能在现代编程课堂中焕发新生。对于正在准备CCF-GESP考试的学生而言，这个问题不仅考察基础编程能力，更蕴含着算法优化的重要思想。本文将带您穿越时空，从《张丘建算经》的智慧结晶出发，逐步拆解如何用C++高效实现这个经典问题的通用解法，并深入分析其在等级考试中的实战应用。

1. 穿越千年的数学智慧：百鸡问题溯源

公元5世纪，北魏数学家张丘建在其著作《张丘建算经》中记录了这个有趣的数学难题："今有鸡翁一，值钱五；鸡母一，值钱三；鸡雏三，值钱一。凡百钱买鸡百只，问鸡翁、母、雏各几何？"这道题看似简单，却需要巧妙的数学思维。

古代解题思路主要体现在消元法的运用上。设公鸡为x只，母鸡y只，小鸡z只，可以建立以下方程组：

5x + 3y + z/3 = 100  
x + y + z = 100

通过消元可以得到7x + 4y = 100的关系式，古人通过试值法在有限范围内寻找整数解。这种思路与现代计算机的枚举思想不谋而合，展现了古代数学家的智慧。

在当代编程教育中，这个问题被CCF-GESP等权威考试选作考题，主要考察三个核心能力：

• 问题抽象能力：将现实问题转化为数学模型
• 边界条件分析：确定枚举的合理范围
• 代码实现技巧：用编程语言高效实现算法

2. 问题抽象与算法设计

现代版的百鸡问题通常扩展为更通用的形式：给定公鸡单价x元，母鸡y元，z只小鸡1元，用n元买m只鸡，求所有可能的购买方案数。这要求我们建立更普适的解题框架。

2.1 数学模型建立

首先需要明确变量关系：

• 设公鸡数量为gj，则花费gj×x元
• 母鸡数量为mj，花费mj×y元
• 小鸡数量为xj = (m - gj - mj)，花费⌈xj/z⌉元

约束条件为：

gj*x + mj*y + (xj/z) ≤ n  
gj + mj + xj = m  
xj必须能被z整除（因为小鸡按组出售）

2.2 枚举算法设计

最直观的解法是双重循环枚举，其核心逻辑如下：

int count = 0;
for (int gj = 0; gj <= min(n/x, m); gj++) {
    for (int mj = 0; mj <= min((n-gj*x)/y, m-gj); mj++) {
        int xj = m - gj - mj;
        if (xj % z != 0) continue;
        if (gj*x + mj*y + xj/z <= n) {
            count++;
        }
    }
}

这个算法的时间复杂度为O(n²)，在给定约束条件下完全可行。但需要注意三个优化点：

1. 枚举范围优化：公鸡数量不超过min(n/x, m)
2. 提前终止条件：当gj*x已超过n时跳出循环
3. 类型一致性检查：确保小鸡数量是z的整数倍

3. C++实现与边界处理

让我们实现一个健壮的解决方案，处理各种边界情况。以下是完整代码框架：

#include <iostream>
#include <algorithm>
using namespace std;

int main() {
    int x, y, z, n, m;
    cin >> x >> y >> z >> n >> m;
    
    int solutions = 0;
    
    for (int gj = 0; gj <= min(n/x, m); ++gj) {
        int remaining_money = n - gj * x;
        if (remaining_money < 0) break;
        
        for (int mj = 0; mj <= min(remaining_money/y, m - gj); ++mj) {
            int xj = m - gj - mj;
            if (xj < 0) continue;
            
            // 检查小鸡数量是否能被z整除且总价不超预算
            if (xj % z == 0 && gj*x + mj*y + xj/z <= n) {
                solutions++;
            }
        }
    }
    
    cout << solutions << endl;
    return 0;
}

关键改进点包括：

• 使用min()函数精确控制循环边界
• 添加remaining_money减少重复计算
• 提前检查xj非负条件
• 清晰的代码注释增强可读性

4. 算法优化与数学分析

虽然枚举法在本题限制下足够高效，但深入分析数学关系可以带来更优解。我们可以将问题转化为线性丢番图方程求解。

4.1 单层循环优化

通过数学变形，可以消去一个变量，将算法优化为O(n)：

int solutions = 0;
for (int gj = 0; gj <= min(n/x, m); ++gj) {
    int remaining = n - gj * x;
    int max_mj = min(remaining / y, m - gj);
    
    // 数学推导得出的mj范围
    int lower_mj = max(0, ceil((z*(m - gj) - remaining*z) / (z*y - 1)));
    int upper_mj = min(max_mj, floor((remaining*z - (m - gj)) / (z*y - 1)));
    
    if (lower_mj <= upper_mj) {
        solutions += upper_mj - lower_mj + 1;
    }
}

4.2 复杂度对比

方法	时间复杂度	空间复杂度	适用场景
双重循环	O(n²)	O(1)	代码简单，小数据量
数学优化	O(n)	O(1)	大数据量，需要性能
动态规划	O(n*m)	O(n*m)	扩展问题，带约束

5. CCF-GESP考试实战技巧

在CCF-GESP二级考试中，这类题目通常考察以下能力点：

1. 输入输出处理：正确读取多个参数

   // 推荐写法
   int x, y, z, n, m;
   cin >> x >> y >> z >> n >> m;
   

2. 循环边界控制：特别注意三种鸡的数量都不能为负

   for (int gj = 0; gj <= min(n/x, m); ++gj)
   

3. 条件判断完整性：检查总价和总数双重条件

   if (gj + mj + xj == m && gj*x + mj*y + xj/z <= n)
   

4. 效率优化意识：避免不必要的计算

   int remaining = n - gj * x; // 减少重复计算
   

考试时建议按照以下步骤进行：

1. 仔细阅读题目，明确所有约束条件
2. 在草稿纸上推导数学关系
3. 先写伪代码确定算法框架
4. 逐步实现并测试边界情况
5. 最后检查输出格式是否符合要求

一个常见的调试技巧是添加临时输出语句验证中间结果：

// 调试用
cout << "gj:" << gj << " mj:" << mj << " xj:" << xj << endl;

6. 扩展思考与实际应用

百鸡问题的变种在现实中有诸多应用场景，比如：

• 资源分配：不同成本的服务器组合满足预算
• 生产计划：多种原料配比达到产量要求
• 投资组合：不同风险产品配置实现收益目标

进一步优化方向包括：

• 并行计算：将枚举任务分配到多个线程
• 记忆化搜索：缓存中间结果避免重复计算
• 剪枝策略：根据数学性质提前终止无效分支

// 并行计算示例(C++17)
#include <execution>
std::for_each(std::execution::par, begin, end, [](auto&& item){
    // 并行处理逻辑
});

在解决这类问题时，最容易忽略的是变量类型的溢出问题。当n和m较大时，中间计算结果可能超出int范围，这时应该使用long long类型：

long long total_cost = static_cast<long long>(gj)*x 
                     + static_cast<long long>(mj)*y 
                     + (xj/z);

7. 常见错误与验证方法

初学者常犯的错误包括：

1. 边界条件错误：

   • 忘记检查xj≥0
   • 忽略小鸡数量必须是z的倍数

2. 整数除法陷阱：

   // 错误写法
   int cost = gj*x + mj*y + xj/z; // 可能丢失精度
   // 正确写法
   int cost = gj*x + mj*y + (xj/z);
   

3. 枚举范围过大导致超时

验证方案正确性的测试用例应该包括：

测试案例	预期结果	检查要点
5 3 3 100 100	4	原始百鸡问题
1 1 1 100 100	5151	全范围枚举
10 5 2 50 10	1	边界情况
2 2 4 20 20	11	小鸡分组验证

在项目实践中，这类算法通常会封装成可重用函数：

int solveChickenProblem(int x, int y, int z, int n, int m) {
    // 实现代码
    return solutions;
}

最后要强调的是，虽然这个问题看似简单，但它完美展现了计算思维的核心：将现实问题抽象为数学模型，设计算法解决，并通过编程实现。这种能力正是CCF-GESP等编程等级考试希望培养和考察的核心素养。