算法概念 与描述

答案：C. 高效性

算法的五大特征是：有穷性、确定性、可行性、输入、输出。高效性不是算法的必要特征——一个算法可以很慢，但只要能在有限时间内完成，它仍然是一个合法的算法。

考点：算法的五大特征是有穷性、确定性、可行性、输入、输出，判断时逐条对照即可。

易错：把“高效性/最优性”当成算法的必要条件，其实一个很慢的算法只要有限步内结束，仍然是合法算法。

答案：C. 条件判断

菱形 = 判断框（是/否分支），矩形 = 处理框，椭圆 = 起止框，平行四边形 = 输入/输出框。

考点：流程图的标准图元：菱形=判断框，矩形=处理框，椭圆=起止框，平行四边形=输入/输出框。

易错：把菱形和平行四边形的含义弄反——（菱形只管“是/否”分支，不负责读写数据）。

答案：B. 枚举法

逐一检查 1~1000 中的每个数，判断是否为偶数（i%2==0），这是典型的枚举法。

考点：枚举法的适用场景是“范围有限、可以逐个检查并逐一判断条件”。

易错：看到“找出所有……”就条件反射选二分或贪心，而本题的数据没有任何单调性，只能逐个枚举。

答案：C

A错（至少1个输出），B错（同一问题可以有多种算法），D错（必须有穷）。C正确：算法可以用自然语言、流程图、伪代码等多种方式描述。

考点：算法描述方式（自然语言、流程图、伪代码）与“有穷、确定、有输入、有输出”四条约束的综合判断。

易错：误认为“算法必须有输入”或“同一个问题只有唯一算法”，这两句话都不成立。

答案：30

模拟执行：x从1到10，只有偶数时才累加：

s = 2 + 4 + 6 + 8 + 10 = 30

这个算法求的是 1~10 中所有偶数的和。

思路：按循环变量 x 从 1 走到 10 逐步跟踪，只在判断框“x 是偶数”成立时执行累加。

易错：把判断条件看成“x 是奇数”，或漏掉最后一次 x=10 的累加，算出 25 之类的错误值。

#include <iostream>
using namespace std;

int main() {
    int count = 0;
    for (int g = 1; g <= 20; g++) {       // 公鸡最多20只
        for (int m = 1; m <= 33; m++) {   // 母鸡最多33只
            int x = 100 - g - m;          // 小鸡数量
            if (x >= 1 && x % 3 == 0) {  // 小鸡至少1只且能被3整除
                if (5*g + 3*m + x/3 == 100) {
                    count++;
                    cout << "公鸡" << g << " 母鸡" << m << " 小鸡" << x << endl;
                }
            }
        }
    }
    cout << "共" << count << "种买法" << endl;
    return 0;
}

公鸡4 母鸡18 小鸡78
公鸡8 母鸡11 小鸡81
公鸡12 母鸡4 小鸡84
共3种买法

思路：用等量关系 g+m+x=100 把三重循环降为双重循环，小鸡数 x 直接由表达式算出后再校验合法性。

易错：只判断 x≥1 却忘了 x%3==0（小鸡按“1 元 3 只”，只数必须能被 3 整除），或漏掉“每种至少 1 只”的限制。

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

// 伪代码：判断正整数 n 是否为素数
// 输入：正整数 n
// 输出：是 / 否
bool isPrime(int n) {
    if (n < 2) return false;              // n < 2，输出“不是素数”，结束
    for (int i = 2; i <= sqrt(n); i++) {  // 对于 i 从 2 到 √n，执行
        if (n % i == 0) return false;     // 若 n % i == 0，输出“不是素数”，结束
    }
    return true;                          // 一个因子都没找到 -> 是素数
}

int main() {
    int n;
    cin >> n;
    if (isPrime(n)) cout << "是素数" << endl;
    else            cout << "不是素数" << endl;
    return 0;
}

答案：伪代码如下（n 为正整数）：
输入：正整数 n　　输出：是 / 否
如果 n < 2，输出“不是素数”，结束
对于 i 从 2 到 √n，执行：
    如果 n % i == 0：
        输出“不是素数”，结束
输出“是素数”

思路：素数是只能被 1 和自己整除、且大于 1 的数。判断时从 2 开始一个个试除，只要有一个 i 能整除 n，n 就不是素数；如果一路试到 √n 都没找到因数，就说明 n 是素数。关键优化是只需检查到 √n：因为如果 n 有一个大于 √n 的因数，那它必然还配着一个小于 √n 的因数，早就被我们发现了。

考点：伪代码的书写规范（输入/输出、判断、循环、提前结束）；素数判定算法；√n 优化把复杂度从 O(n) 降到 O(√n)。

易错：① 忘记特判 n < 2，导致 1 被判成素数；② 循环上界写成 i < n（没优化）或 i < √n（漏掉完全平方数，如 9=3×3），应写 i <= sqrt(n) 或 i*i <= n；③ 用 sqrt 时要留心浮点误差，写 i*i <= n 更稳。

模拟过程：

初始：顶=1, 底=6, 前=2, 后=5, 左=3, 右=4

第1次（向前翻）：顶=5, 底=2, 前=1, 后=6, 左=3, 右=4

第2次（向右翻）：顶=3, 底=4, 前=1, 后=6, 左=2, 右=5

第3次（向前翻）：顶=6, 底=1, 前=3, 后=4, 左=2, 右=5

第4次（向右翻）：顶=2, 底=5, 前=3, 后=4, 左=1, 右=6

最终顶面 = 2

思路：把骰子的顶/底/前/后/左/右六个面写成变量，每翻一次按规则整体更新这组变量再继续下一步。

易错：翻动时只改“顶面”而忘了同步更新底面和四个侧面，后面的步骤会全部算错。

答案：C（4个）

① ✅ 有穷性   ② ✅ 确定性   ③ ✅ 可以没有输入

④ ❌ 算法必须至少有一个输出   ⑤ ✅ 正确

④ 和 ⑤ 是矛盾的，⑤ 正确则 ④ 错误。共 4 个正确。

考点：逐条比对算法五大特征，注意“输入可以为 0 个”，而“输出至少要有 1 个”。

易错：凭印象直接数条数，遇到两条表述互相矛盾时又以错的那条为准——应以课本定义为唯一标准。

答案：B. 91

该算法计算 1²+2²+3²+4²+5²+6²

= 1 + 4 + 9 + 16 + 25 + 36 = 91

思路：循环累加的项是 i²，i 从 1 走到 n，把 n=6 代入逐项求出平方和。

易错：把 i² 当成 i 本身累加（得到 21），或漏加最后一项 36。

#include <iostream>
using namespace std;

int main() {
    for (int n = 100; n <= 999; n++) {
        int a = n / 100;
        int b = (n / 10) % 10;
        int c = n % 10;
        if (a + b + c == a * b * c) {
            cout << n << " ";
        }
    }
    cout << endl;
    return 0;
}

123 132 213 231 312 321

满足条件的数都是 1、2、3 的排列，因为 1+2+3 = 6 = 1×2×3。

思路：枚举 100~999，用 n/100、(n/10)%10、n%10 拆出百十个位，再比较数位和与数位积是否相等。

易错：拆位时整除与取余混用（如写成 n%100/10 之外的错误组合），取到的不是对应位的数字。

#include <iostream>
using namespace std;

int main() {
    int result;
    cin >> result;  // 读入第一个数

char op;
    while (cin >> op) {
        int num;
        cin >> num;
        if (op == '+') result += num;
        else if (op == '-') result -= num;
        else if (op == '*') result *= num;
        else if (op == '/') result /= num;
    }
    cout << result << endl;
    return 0;
}

输入: 3 + 5 * 2 - 1
输出: 15
（从左到右：(3+5)=8, 8*2=16, 16-1=15）

注意：这是从左到右计算（不考虑运算符优先级），与标准数学运算不同。如果需要考虑优先级，则需要更复杂的算法（如栈或递归下降）。

思路：先读入第一个数作为当前结果，再循环“读运算符→读下一个数→按运算符更新结果”，把表达式从左到右逐段折叠。