非常感谢你提供这份详尽的北师大版小学数学三年级教学大纲。

基于北师大版课本的编排顺序，我们将原本的奥数与信奥（C++）自学讲义进行深度对齐。这样，你在学校学完一个单元的基础知识后，就可以直接无缝对接相应的“奥数思维拓展”和“信奥算法实践”，做到学以致用。

🗺️ 北师大版三年级：课内 ➔ 奥数 ➔ 信奥对齐大纲

以下是为你量身定制的双轨拓展大纲：

📖 深度对齐讲义示范

为了让你更直观地学习，我们精选了两个与北师大教材关联最紧密的专题。

💻 专题一：年、月、日 中的周期与逻辑

本讲对应：北师大版三年级上册 第七单元《年、月、日》

1. 课内基础回顾

在学校里，我们学习了： * 大月（31天）：1、3、5、7、8、10、12月。 * 小月（30天）：4、6、9、11月。 * 二月：平年 28 天，闰年 29 天。 * 闰年判定规律：四年一闰，百年不闰，四百年又闰（年份是4的倍数，但如果是整百年，必须是400的倍数）。

2. 奥数拓展：星期与日历推算

在奥数中，日历问题通常是周期问题的变形。因为星期是以 7 为周期循环的（周一到周日）。

【奥数例题】：已知 2026 年的 8 月 1 日是星期六。问：2026 年的国庆节（1010月 1 日）是星期几？ [5]

• 分析与步骤：
  1. 计算经过的天数：我们需要计算从 8 月 1 日到 10 月 1 日一共经过了多少天。
     • 8 月是大月，有 31 天。从 8 月 1 日到 8 月 31 日，需要经过 $31 - 1 = 30$ 天。
     • 9 月是小月，有 30 天。
     • 10 月 1 日，需要再走 1 天。
     • 总天数 = $30 + 30 + 1 = 61$ 天。
  2. 求余数：$61 \div 7 = 8 \dots 5$（一共过了 8 个星期，还多出 5 天）。
  3. 推算星期：从星期六往后数 5 天：
     • 第1天：星期日
     • 第2天：星期一
     • 第3天：星期二
     • 第4天：星期三
     • 第5天：星期四。
  4. 答：2026 年的国庆节是星期四。

3. 信奥实践：用 C++ 逻辑来判定闰年

在信息学竞赛中，“判断闰年”是一道最经典的入门题。我们需要把数学中的“四年一闰，百年不闰，四百年又闰”转化为计算机的逻辑表达式。

• 逻辑转换：

  • 年份能被 4 整除（year % 4 == 0） 并且 不能被 100 整除（year % 100 != 0）
  • 或者
  • 年份能被 400 整除（year % 400 == 0）

• C++ 核心代码：

#include <iostream>
using namespace std;

int main() {
    int year;
    cout << "请输入年份: ";
    cin >> year;

    // && 表示“并且”，|| 表示“或者”
    if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
        cout << year << " 年是【闰年】" << endl;
    } else {
        cout << year << " 年是【平年】" << endl;
    }

    return 0;
}

✏️ 举一反三（巩固练习）

• 数学练习：2026 年是平年（2月有28天）。如果 2026 年的 2 月 1 日是星期日，那么这一年的 3 月 1 日是星期几？
• 信奥思考：如果用上面的 C++ 闰年程序，输入 2026，程序输出的结果会是什么？

练习解析： 1. 2月有28天。因为 $28 \div 7 = 4 \dots 0$（正好是 4 个完整的星期，余数为 0）。所以 3 月 1 日与 2 月 1 日的星期完全相同，也是星期日。 2. 2026 既不能被 4 整除，也不能被 400 整除，程序会运行 else 分支，输出：2026 年是【平年】。

💻 专题二：乘法中的“数位拆分”与枚举

本讲对应：北师大版三年级下册 第三单元《乘法》（两位数乘两位数）

1. 课内基础回顾

在课内，我们通过“点子图”或“表格法”学习了两位数乘法。例如算 $12 \times 14$： * 我们会把 14 拆成 $10 + 4$。 * 先算 $12 \times 4 = 48$，再算 $12 \times 10 = 120$。 * 最后合起来 $48 + 120 = 168$。 * 这背后的核心思想是数位拆分（把一个数拆成十位和个位）。

2. 奥数拓展：乘法竖式数字谜

奥数常常会把竖式中的某些数字藏起来，让我们去“破译”。

【奥数例题】：在下面的乘法竖式中，每个字母代表一个不同的数字，求 A、B、C 分别代表什么数字？ text A B × C ——————— 1 1 2

• 分析与步骤：
  1. 观察个位数：$B \times C$ 的个位数是 $2$。在个位数乘法中，积的个位是 2 的组合有：$1 \times 2$，$2 \times 6$，$3 \times 4$，$4 \times 8$，$7 \times 6$ 等。
  2. 观察十位数：两位数 $AB$ 乘一位数 $C$，结果才一百一十多，说明 $C$ 的数值不能太大。
  3. 尝试与推理：
     • 如果 $C = 2$：那么两位数 $AB = 112 \div 2 = 56$。此时 $A=5, B=6, C=2$。三个数字各不相同，符合题意。
     • 如果 $C = 3$：$112$ 不能被 3 整除，排除。
     • 如果 $C = 4$：$AB = 112 \div 4 = 28$。此时 $A=2, B=8, C=4$。三个数字也各不相同，同样符合题意！
  4. 答：这道题有多个答案。其中一组是 $A=5, B=6, C=2$（算式为 $56 \times 2 = 112$），另一组是 $A=2, B=8, C=4$（算式为 $28 \times 4 = 112$）。

3. 信奥实践：C++ 中的“数位提取”技术

计算机非常擅长做这种“猜数字”的填空题。但要让计算机猜，我们首先得教会它如何把一个两位数拆开成十位和个位。 * 在 C++ 中，假设一个两位数 num = 56： * 提取个位数：num % 10 （$56 \div 10$ 的余数是 6）。 * 提取十位数：num / 10 （$56 \div 10$ 整数部分是 5）。

利用这个性质，我们可以写一个 C++ 程序，让计算机把所有满足 $AB \times C = 112$ 的情况全部找出来：

#include <iostream>
using namespace std;

int main() {
    // 让一位数 C 从 1 循环到 9
    for (int C = 1; C <= 9; C++) {
        // 让两位数 AB 从 10 循环到 99
        for (int AB = 10; AB <= 99; AB++) {

            // 如果满足乘法结果是 112
            if (AB * C == 112) {
                // 拆分 AB 的十位 A 和个位 B
                int A = AB / 10;
                int B = AB % 10;

                // 题目要求 A、B、C 是不同的数字
                if (A != B && B != C && A != C) {
                    cout << "找到一组答案: ";
                    cout << "A=" << A << ", B=" << B << ", C=" << C;
                    cout << " (算式: " << AB << " * " << C << " = 112)" << endl;
                }
            }

        }
    }
    return 0;
}

当你运行这段程序，电脑会在一瞬间帮你把上面我们费尽心思推理出来的两组答案全部打印在屏幕上！这就是计算机编程的魅力。

✏️ 举一反三（巩固练习）

• 数学练习：一个两位数，十位上的数字是个位上数字的 3 倍。这个两位数乘 3 得到的积还是一个两位数。这个两位数是多少？
• 信奥思考：在 C++ 中，如果我们有一个三位数 num = 312（对应三下除法单元），我们该如何用 / 和 % 提取它的百位数呢？

练习解析： 1. 十位是个位的3倍，这样的两位数只有：31、62、93。 * $31 \times 3 = 93$（是两位数，符合题意）。 * $62 \times 3 = 186$（变成三位数了，排除）。 * 所以这个两位数是 31。 2. 提取三位数的百位数，可以直接除以 100：num / 100（$312 \div 100$ 的整数商是 3）。

💻 专题三：算式的奥秘 —— 等差数列与循环累加

本讲对应：北师大版三年级上册 第一、三单元《混合运算 / 加与减》

1. 课内基础回顾

在学校里，我们学习了三位数连加（如 $256 + 189 + 75$），并且学会了利用“凑整法”进行估算（比如 $398 + 203 \approx 400 + 200$）。这些都是为了让我们算得更快、更准。

2. 奥数拓展：等差数列求和（高斯求和）

如果让你计算 $1 + 2 + 3 + 4 + \dots + 99 + 100$ 的和，你会怎么算？如果一个一个硬加，不仅容易算错，而且要花很长时间。

奥数中有一个著名的等差数列求和公式（相传是数学家高斯小时候发现的）：

$$\text{总和} = (\text{首项} + \text{末项}) \times \text{项数} \div 2$$

• 首项：数列的第一个数（这里是 $1$）
• 末项：数列的最后一个数（这里是 $100$）
• 项数：一共有多少个数（这里是 $100$）

【奥数例题】：求等差数列 $3 + 6 + 9 + 12 + \dots + 297 + 300$ 的和。

• 分析与步骤：
  1. 确定首项和末项：首项是 $3$，末项是 $300$。
  2. 计算项数：这个数列每个数都比前一个多 $3$（公差是 $3$）。所以项数 = $300 \div 3 = 100$ 个。
  3. 套用公式： $$\text{总和} = (3 + 300) \times 100 \div 2 = 303 \times 100 \div 2 = 30300 \div 2 = 15150$$
  4. 答：这组数的和是 15150。

3. 信奥实践：让计算机去“老老实实地加”

在信奥中，我们可以用两种方法让计算机解决这道题。通过对比，你会发现数学对计算机算法的威力。

方法 A：老实人的办法（循环累加）

计算机不嫌累，我们可以写一个 for 循环，从 $3$ 开始，每次加 $3$，一直加到 $300$。 我们用一个叫做 sum 的“变量盒子”来存每次加完的结果。

#include <iostream>
using namespace std;

int main() {
    int sum = 0; // 这是一个空盒子，用来装累加的和

    // i 从 3 开始，每次增加 3 (i += 3)，直到超过 300
    for (int i = 3; i <= 300; i += 3) {
        sum = sum + i; // 把当前的数 i 放进盒子
    }

    cout << "老实人办法算出的和是: " << sum << endl;
    return 0;
}

方法 B：数学家的办法（公式法）

我们直接把高斯的数学公式写进代码里。计算机不需要循环，直接“一步到位”得出答案！

#include <iostream>
using namespace std;

int main() {
    int first = 3;   // 首项
    int last = 300;  // 末项
    int n = 100;     // 项数

    // 直接用公式计算
    int sum = (first + last) * n / 2;

    cout << "数学公式法算出的和是: " << sum << endl;
    return 0;
}

💡 信奥核心思维：什么是“时间复杂度”？

• 如果我们要算从 1 加到 10亿。
• 用方法 A，计算机里的 for 循环需要老老实实运行 10亿次，程序可能会卡住好几秒，甚至在信奥比赛中因为“运行超时（TLE）”而得零分。
• 用方法 B，计算机只需要做 1次加法、1次乘法、1次除法，不管数字多大，都可以在 $0.0001$ 秒内瞬间算出答案！
• 这就是为什么说“学好奥数，能让你的程序运行得比别人快成百上千倍”。

✏️ 举一反三（巩固练习）

• 数学练习：计算 $1 + 3 + 5 + 7 + \dots + 99$ 的和。（提示：先数一数 1 到 99 之间一共有多少个奇数）
• 信奥思考：如果我们要计算 $1 + 2 + 3 + \dots + N$（$N$ 是用户输入的一个任意大正整数），用方法 B 的思路，C++ 的计算公式应该怎么写？

练习解析： 1. 项数：$(99 - 1) \div 2 + 1 = 50$ 个。总和 = $(1 + 99) \times 50 \div 2 = 100 \times 50 \div 2 = 2500$。 2. C++ 公式写为：int sum = (1 + N) * N / 2;。

💻 专题四：图形的运动 —— 平移与坐标模拟

本讲对应：北师大版三年级下册 第二单元《图形的运动》（平移现象）

1. 课内基础回顾

在课内，我们通过“推拉窗户”、“电梯升降”认识了平移。平移的特征是：物体沿着直线移动，它的大小和形状完全不改变，只是位置发生了变化。

2. 奥数拓展：平面直角坐标系初步

在奥数和初中数学中，我们用坐标来精准描述位置。 * 想象有一张方格纸，上面有一条横着的轴叫 X轴（向右数字变大），一条竖着的轴叫 Y轴（向上数字变大）。它们交汇的地方叫原点 $(0, 0)$。 * 每一个点都可以用一对数字 $(x, y)$ 来表示。

【奥数例题】：一个机器人在方格纸上运动，它一开始停在点 $(2, 3)$ 处。 1. 如果它向右平移 4 个格，它到达的新位置坐标是多少？ 2. 接着，它又向上平移 3 个格，此时它的坐标是多少？

• 分析与步骤：
  1. 向右平移：横向位置改变。向右平移 4 格，意味着 X 坐标要加上 4，Y 坐标保持不变。
     • 新坐标 X = $2 + 4 = 6$，Y 依旧是 $3$。所以新位置是 $(6, 3)$。
  2. 向上平移：纵向位置改变。向上平移 3 格，意味着 Y 坐标要加上 3，X 坐标保持不变。
     • 新坐标 Y = $3 + 3 = 6$，X 依旧是 $6$。所以最终位置是 $(6, 6)$。
  3. 答：向右平移后是 $(6, 3)$；再向上平移后是 $(6, 6)$。

3. 信奥实践：游戏开发中的“角色移动与碰撞”

在编写电脑游戏（比如《我的世界》或《王者荣耀》）时，游戏角色的移动本质上就是坐标的加减法（平移）。

下面我们用 C++ 模拟一个经典场景：一个机器人在 $5 \times 5$ 的地图里走动（坐标范围是 0 到 4）。为了防止机器人走出地图，我们需要在平移时加上“边界判定”。

#include <iostream>
using namespace std;

int main() {
    // 机器人的初始位置
    int x = 2;
    int y = 2;
    cout << "初始位置: (" << x << ", " << y << ")" << endl;

    // 我们给机器人下达一个移动指令：向右移动 3 格
    int move_right = 3;

    // 在平移前，我们需要判断：平移后会不会掉出地图（也就是 x 坐标是否会超过 4）？
    if (x + move_right > 4) {
        cout << "【警告】向右平移 " << move_right << " 格会撞墙！机器人停在边界。" << endl;
        x = 4; // 撞墙后停在最右边
    } else {
        x = x + move_right; // 安全平移
    }

    cout << "当前位置: (" << x << ", " << y << ")" << endl;
    return 0;
}

💡 信奥核心思维：模拟（Simulation）

在信奥比赛中，有一类题目叫做“模拟题”。就是题目给你一个规则，让你用代码把这个规则一步一步实现出来。上面的“机器人走格子”就是最基础的二维坐标模拟算法。

✏️ 举一反三（巩固练习）

• 数学练习：一个点 A 先向左平移 3 个格，再向下平移 2 个格，到达了新位置 $(1, 4)$。请问：点 A 原来的坐标是多少？（提示：逆向思维，把移动过程反过来做）
• 信奥思考：如果游戏中的角色要向左移动，我们要对 x 变量做加法还是减法？如果要向下移动，要对 y 变量做加法还是减法？

练习解析： 1. 原来位置往左走3格、往下走2格才到 $(1, 4)$。反过来，从 $(1, 4)$ 往右走3格、往上走2格就能回到原位。 * 原来的 X = $1 + 3 = 4$ * 原来的 Y = $4 + 2 = 6$ * 所以原来的坐标是 $(4, 6)$。 2. 向左移动，x 坐标减小，所以做减法 (x = x - 移动距离)；向下移动，y 坐标减小，所以也做减法 (y = y - 移动距离)。

💻 专题五：除法的深层奥秘 —— 鸽巢原理 与 桶计数

本讲对应：北师大版三年级下册 第一单元《除法》

1. 课内基础回顾

在三年级下册第一单元，我们学习了三位数除以一位数，并学会了用“商 × 除数 + 余数 = 被除数”来进行验算。

2. 奥数拓展：鸽巢原理（抽屉原理）

除法中有一个著名的思考方向：把东西平均分配。如果分不均匀，就会产生一种有趣的数学定理——鸽巢原理。

鸽巢原理最简单的说法： 如果你有 5 只鸽子，要飞进 4 个鸽巢里，那么至少有一个鸽巢里飞进了 2 只或 2 只以上的鸽子。

这个定理听起来像一句废话，但在奥数中，它是解决“存在性证明”问题的无上利器。

【奥数例题】：在一张聚会上，一共有 13 个人。请你证明：他们当中至少有两个人是在同一个月份出生的。

• 证明与推理：
  1. 确定“鸽巢”：一年一共有 12 个月份。我们可以把这 12 个月份看成 12 个“鸽巢”。
  2. 确定“鸽子”：聚会上的 13 个人就是 13 只“鸽子”。
  3. 平均分配（除法）：$13 \div 12 = 1 \dots 1$。
     • 这意味着，即使我们让这 13 个人尽量均匀地分布在不同的月份里，每个月分到 1 个人之后，还剩下 1 个人。这最后一个人无论放进哪个月份，那个月份就都会有 2 个人。
  4. 结论：因此，至少有两个人是在同一个月份出生的。

3. 信奥实践：用“桶（Bucket）”来统计数据

在信奥中，如何让计算机找出哪些人在同一个月出生，或者统计每个月份分别有多少人呢？

这就需要用到一种非常经典的算法数据结构：桶计数（或者叫计数排序思想）。 * 我们可以创建 12 个“桶”（在代码中表现为大小为 13 的数组，为了方便，下标 1 到 12 分别代表 12 个月，初始值都设为 0） [3]。 * 每遇到一个人，我们就看看他的生日月份，并在对应的“桶”里加 1 [3]。

#include <iostream>
using namespace std;

int main() {
    // 假设这 13 个人的出生月份分别是：
    int birth_months[13] = {1, 5, 3, 12, 5, 8, 9, 2, 11, 7, 4, 10, 5};

    // 创建 13 个桶（下标 0 不用，只用 1 到 12），初始值全部设为 0
    int buckets[13] = {0}; 

    // 开始统计，让每个人飞进对应的“月份桶”里 [3]
    for (int i = 0; i < 13; i++) {
        int month = birth_months[i]; // 获取当前人的月份
        buckets[month]++;            // 对应的月份桶计数加 1 [3]
    }

    // 检查哪些桶里的“鸽子”大于等于 2
    for (int m = 1; m <= 12; m++) {
        if (buckets[m] >= 2) {
            cout << m << " 月份有 " << buckets[m] << " 个人出生，符合鸽巢原理！" << endl;
        }
    }

    return 0;
}

💡 信奥核心思维：桶计数（Bucket Count）

这个算法非常神奇：我们不需要把这 13 个人两两进行比较，只需要扫描一遍数据，把它们各归其“桶”，就能瞬间找出重复的数据 [3]。它是高阶算法（如哈希表、基数排序）的基石。

✏️ 举一反三（巩固练习）

• 数学练习：一个黑暗的盒子里有红、黄、蓝三种颜色的袜子各 10 只。如果你闭着眼睛去拿，至少要拿多少只袜子，才能保证其中一定有一双（2只）同颜色的袜子？（提示：想一想什么是“鸽巢”）
• 信奥思考：如果我们要统计班里 40 个同学的数学成绩（假设成绩都是整数，且在 0 到 100 分之间），我们的“桶数组”应该开多大？

练习解析： 1. “鸽巢”是颜色。这里有红、黄、蓝共 3 个鸽巢。为了确保至少有两只袜子颜色相同（2只鸽子在同一个巢里），我们需要袜子的数量（鸽子数）大于鸽巢数。所以至少要拿 $3 + 1 = 4$ 只袜子。 2. 成绩在 0 到 100 之间，一共有 101 种可能的得分（包括0分）。因此我们的桶数组大小至少要开到 101（即 int buckets[101]），用来存放 0 到 100 分的得分人数。

💻 专题六：分数的妙用 —— 最简分数 与 最大公约数（GCD）

本讲对应：北师大版三年级下册 第六单元《认识分数》

1. 课内基础回顾

在学校里，我们初步认识了分数。我们知道，把一个蛋糕平均分成 4 份，其中的 2 份就是 $\frac{2}{4}$，其实它也等于半个蛋糕，也就是 $\frac{1}{2}$。这种把分子和分母同时除以相同的数、使分数变简单的过程，在数学上叫做约分。

2. 奥数拓展：寻找最大公约数（GCD）

要把分数 $\frac{12}{18}$ 化成最简分数，我们需要找到分子 12 和分母 18 的最大公约数（也就是能同时整除它们俩的最大整数）。

• 12 的因数有：1, 2, 3, 4, 6, 12。
• 18 的因数有：1, 2, 3, 6, 9, 18。
• 它们的公因数有：1, 2, 3, 6。其中最大的是 6。
• 约分：$\frac{12 \div 6}{18 \div 6} = \frac{2}{3}$。

但是，如果数字非常大（比如 $\frac{221}{323}$），我们很难一眼看出它们的公因数。这时候，我们就需要用到一种古老的数学算法。

3. 信奥实践：中国古人的智慧——“更相减损术”

在我国古代数学名著《九章算术》中，记录了一种寻找最大公约数的方法，叫更相减损术。它的原理非常简单：

要找两个数 $A$ 和 $B$ 的最大公约数： 如果 $A > B$，就用 $A - B$ 代替 $A$； 如果 $B > A$，就用 $B - A$ 代替 $B$； 一直重复这个过程，直到这两个数相等。这个相等的数就是它们的最大公约数！

这个“重复相减直到相等”的过程，简直就是天生为计算机的 while 循环设计的！

#include <iostream>
using namespace std;

int main() {
    int a = 18;
    int b = 12;

    // 保存原始值，用来后面输出分数
    int original_a = a;
    int original_b = b;

    // 当 a 不等于 b 时，一直重复做减法
    while (a != b) {
        if (a > b) {
            a = a - b; // 用大数减小数，并更新大数
        } else {
            b = b - a; // 用大数减小数，并更新大数
        }
    }

    // 循环结束时，a 就是最大公约数
    int gcd = a; 

    cout << "最大公约数是: " << gcd << endl;
    cout << "分数 " << original_a << "/" << original_b 
         << " 约分后的最简分数是: " 
         << original_a / gcd << "/" << original_b / gcd << endl;

    return 0;
}

💡 信奥核心思维：循环控制（while 循环）

我们在前面的专题中用的都是 for 循环（提前知道要循环多少次）。而在这里，我们不知道要相减多少次，只知道“直到两个数相等才停下来”。这时候，使用 while 循环是最佳的选择。

✏️ 举一反三（巩固练习）

• 数学练习：利用更相减损术，在纸上手算一下 35 和 21 的最大公约数是多少？写出每一次相减后的结果。
• 信奥思考：更相减损术虽然简单，但如果用它算 $10000$ 和 $1$ 的最大公约数，需要做 $9999$ 次减法，太慢了。我们可以用除法（取模运算 %）来代替相减。这就是著名的“辗转相除法”。你能试着用自然语言描述一下，除法是如何加速这个过程的吗？

练习解析： 1. 第一步：$35 - 21 = 14$（剩下 21 和 14） 第二步：$21 - 14 = 7$（剩下 14 和 7） 第三步：$14 - 7 = 7$（剩下 7 和 7，相等了！） 所以最大公约数是 7。 2. 减法的本质是重复。比如 $10000$ 一直减去 $1$，要减 $9999$ 次，最后余数是 $0$。而用除法 $10000 \div 1 = 10000 \dots 0$，一步就能得到余数 $0$。所以，把“大数减小数”优化成“大数除以小数求余数”，就是威力无比的“辗转相除法”。

为你将北师大三年级大纲中剩余的四大核心领域（空间、量感、数据、数论）一次性全部梳理完毕，并设计成对应的融合讲义与代码实现。

至此，北师大三年级数学课内、奥数、信奥三者的知识图谱便全部拼装完整。

💻 专题七：观察物体与面积 ➔ 二维网格与矩阵

对应课内：三上 第二单元《观察物体》 与 三下 第五单元《面积》

1. 课内基础与奥数拓展

在课内，我们学习了从不同方向观察由小正方体搭成的立体图形，以及用平方厘米等单位计算平面图形的面积。 * 奥数拓展（三视图与立体计数）：如果告诉你一个立体图形的正面视图和侧面视图，我们能推算出这个立体图形最少由多少个小正方体搭成，最多由多少个搭成。为了在数学中记录这些方块，我们会用一个网格图，在每个方格里写上这个位置叠了几个方块。

2. 信奥实践：用“二维数组”描述空间

在计算机中，我们用 二维数组（Matrix，矩阵） 来表示这种网格、地图或三视图。 * int grid[3][3] 可以表示一个 $3 \times 3$ 的网格。 * 例如，grid[row][col] = height 表示在第 row 行、第 col 列堆叠了 height 个小正方体。

下面的 C++ 代码可以帮我们自动计算出一个叠好的积木城堡一共有多少个小正方体，并判断从正前方看过去能看到多高。

#include <iostream>
#include <algorithm> // 引入 max 函数
using namespace std;

int main() {
    // 1. 定义一个 3x3 的网格，里面存放每个位置叠放的积木高度
    int grid[3][3] = {
        {1, 3, 0}, // 第一行
        {2, 1, 1}, // 第二行
        {0, 2, 4}  // 第三行
    };

    // 2. 统计一共有多少个正方体
    int total_blocks = 0;
    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 3; c++) {
            total_blocks += grid[r][c];
        }
    }
    cout << "积木城堡一共有: " << total_blocks << " 个正方体。" << endl;

    // 3. 模拟“从正面看”：正前方的每一列，我们只能看到这一列里最高的那个积木
    cout << "从正面看，三列看到的高度分别是: ";
    for (int col = 0; col < 3; col++) {
        int max_height = 0;
        for (int row = 0; row < 3; row++) {
            max_height = max(max_height, grid[row][col]); // 找出这一列的最大高度
        }
        cout << max_height << " ";
    }
    cout << endl;

    return 0;
}

• 练习：手算一下，如果把第三行第三列的积木高度从 4 变为 5，从正面看过去，最右边一列的高度会发生变化吗？为什么？ > 答案：会变。因为最后一列的最大高度变成了 5，所以从正面看最右侧的高度会从 4 变成 5。

💻 专题八：千克、克、吨 ➔ 砝码称重与二进制状态

对应课内：三下 第四单元《千克、克、吨》

1. 课内基础与奥数拓展

在课内，我们认识了质量单位，并知道了它们之间的换算关系：$1\text{ t} = 1000\text{ kg}$，$1\text{ kg} = 1000\text{ g}$。 * 奥数拓展（天平称重问题）：如果天平只能在右盘放砝码，左盘放物品。现在要称出 $1\text{ g}$ 到 $15\text{ g}$ 之间所有整克数的物品，我们最少需要准备几个砝码？分别是多少克？ * 数学原理：答案是 4 个砝码，分别是 $1\text{ g}, 2\text{ g}, 4\text{ g}, 8\text{ g}$。 * 要称 $3\text{ g}$：用 $1\text{ g} + 2\text{ g}$。 * 要称 $11\text{ g}$：用 $1\text{ g} + 2\text{ g} + 8\text{ g}$。 * 通过这四个数字的任意组合，我们可以“拼凑”出 $1$ 到 $15$ 之间的任何整数。这背后的核心原理就是二进制（$1, 2, 4, 8$ 分别对应二进制的第 0, 1, 2, 3 位）。

2. 信奥实践：用代码模拟“砝码组合”

在信奥中，如何让计算机帮我们自动判断，用 $1, 2, 4, 8$ 克砝码能否拼出某个目标重量 $W$？ 我们可以用最基础的选择逻辑（选或不选，即 0 或 1）来模拟。

#include <iostream>
using namespace std;

int main() {
    int target_weight;
    cout << "请输入你想称的重量 (1-15g): ";
    cin >> target_weight;

    // 如果输入的重量不合法
    if (target_weight < 1 || target_weight > 15) {
        cout << "超出称重范围！" << endl;
        return 0;
    }

    cout << target_weight << "g 需要用到以下砝码组合: " << endl;

    int temp = target_weight;
    // 我们从最大的 8g 砝码开始判断
    if (temp >= 8) {
        cout << "[ 8g 砝码 ]" << endl;
        temp -= 8;
    }
    if (temp >= 4) {
        cout << "[ 4g 砝码 ]" << endl;
        temp -= 4;
    }
    if (temp >= 2) {
        cout << "[ 2g 砝码 ]" << endl;
        temp -= 2;
    }
    if (temp >= 1) {
        cout << "[ 1g 砝码 ]" << endl;
        temp -= 1;
    }

    return 0;
}

• 练习：如果你有 $1\text{ g}, 2\text{ g}, 4\text{ g}, 8\text{ g}, 16\text{ g}$ 五个砝码，它们最大能称出多少克的物品？ > 答案：$1 + 2 + 4 + 8 + 16 = 31\text{ g}$。这也是二进制中 5 个二进制位能表示的最大十进制整数。

💻 专题九：数据的整理和表示 ➔ 容斥原理与集合逻辑

对应课内：三下 第七单元《数据的整理和表示》

1. 课内基础与奥数拓展

在课内，我们学习了用“打勾”或“画圈”来整理数据，并制作统计表。 * 奥数拓展（容斥原理/重叠问题）： 三（1）班有 20 个人喜欢画画，有 15 个人喜欢唱歌，其中既喜欢画画又喜欢唱歌的有 5 个人。问：喜欢画画或唱歌的一共有多少人？ * 很多同学会直接算 $20 + 15 = 35$。但这样就把那 5 个两样都喜欢的人重复计算了两次。 * 正确公式：总人数 = 喜欢画画人数 + 喜欢唱歌人数 - 既喜欢画画又喜欢唱歌的人数。 * 即：$20 + 15 - 5 = 30$ 人。这个规律在奥数中叫做容斥原理（也叫韦恩图逻辑）。

2. 信奥实践：用布尔逻辑剔除重复数据

在信奥中，我们经常要处理含有重复元素的集合。在 C++ 中，逻辑运算符 并且（&&） 与 或者（||） 是处理重叠逻辑的核心。

下面我们模拟一个同学名单。通过布尔值判断，计算出满足其中一个条件或同时满足两个条件的去重人数。

#include <iostream>
using namespace std;

// 定义一个结构体表示学生信息
struct Student {
    string name;
    bool likes_art;  // 是否喜欢画画
    bool likes_music;// 是否喜欢唱歌
};

int main() {
    // 假定班里有 5 个学生
    Student students[5] = {
        {"小明", true,  false}, // 只喜欢画画
        {"小红", true,  true},  // 两个都喜欢
        {"小刚", false, true},  // 只喜欢唱歌
        {"小华", true,  false}, // 只喜欢画画
        {"小丽", false, false}  // 两个都不喜欢
    };

    int count_any = 0;  // 喜欢画画或唱歌的总人数
    int count_both = 0; // 两个都喜欢的总人数

    for (int i = 0; i < 5; i++) {
        // 两个都喜欢：likes_art 并且 likes_music
        if (students[i].likes_art && students[i].likes_music) {
            count_both++;
        }
        // 喜欢其中任何一个：likes_art 或者 likes_music
        if (students[i].likes_art || students[i].likes_music) {
            count_any++;
        }
    }

    cout << "两样都喜欢的有: " << count_both << " 人。" << endl;
    cout << "喜欢画画或唱歌（已去重）的有: " << count_any << " 人。" << endl;

    return 0;
}

• 练习：在上面的学生名单中，如果我们要找出“喜欢画画但不喜欢唱歌”的人，C++ 的 if 判断条件应该怎么写？（提示：C++ 中表示“不”或“非”的符号是 !） > 答案：if (students[i].likes_art && !students[i].likes_music)。

💻 专题十：乘与除的进阶 ➔ 巧妙的整除判定与数位求和

对应课内：三上 第四单元《乘与除》 与 三下 第一单元《除法》

1. 课内基础与奥数拓展

在课内，我们学习了整十、整百数的乘除法。 * 奥数拓展（整除特征）：在不进行竖式计算的情况下，如何快速判断一个很大的数能不能被 3 整除？ * 数学原理：如果一个数各个数位上的数字之和能被 3 整除，那么这个数就一定能被 3 整除。 * 例如：$258$。各个数位和为 $2 + 5 + 8 = 15$。因为 $15$ 能被 3 整除（$15 \div 3 = 5$），所以 $258$ 一定能被 3 整除（$258 \div 3 = 86$）。

2. 信奥实践：利用“循环拆位”判定整除

在信息学竞赛中，我们经常要处理几位数、十几位数的数字特征。利用我们在专题二学过的“数位拆分”，配合 while 循环，我们可以写出一个程序，让它自动剥离任意大整数的每一位，并求和。

#include <iostream>
using namespace std;

int main() {
    int num;
    cout << "请输入一个整数: ";
    cin >> num;

    int original_num = num;
    int digit_sum = 0; // 用来存放数位和

    // 利用 while 循环，只要 num 还没被剥离成 0，就继续剥离
    while (num > 0) {
        int last_digit = num % 10; // 取出当前最低位的数字
        digit_sum += last_digit;   // 累加到总和中
        num = num / 10;            // 去掉最低位
    }

    cout << original_num << " 的各位数字之和是: " << digit_sum << endl;

    // 判断是否能被 3 整除
    if (digit_sum % 3 == 0) {
        cout << "根据奥数整除原理，" << original_num << " 【可以】被 3 整除！" << endl;
    } else {
        cout << "根据奥数整除原理，" << original_num << " 【不能】被 3 整除！" << endl;
    }

    return 0;
}

• 练习：手算一下，如果输入数字 12345，它的数位之和是多少？它能被 3 整除吗？ > 答案：数位和为 $1 + 2 + 3 + 4 + 5 = 15$。因为 $15 \div 3 = 5$ 余 0，所以 12345 可以被 3 整除。

🎓 三年级奥数与信奥自学结语

当你把上面所有的专题都亲自动手推导、在电脑里写出代码并运行成功后，你其实已经不知不觉地跨过了三年级思维拓展（奥数）和初级信息学基础（信奥）的门槛。

接下来你可以怎么做？

1. 多动手写代码：不要只是“看”代码。把代码一行行敲进编译器里，故意改错一两个符号，看看编译器会报什么错。学会“看懂报错并修改”是成为编程高手最重要的能力。
2. 注重数形结合：无论是在学学校的数学、奥数还是信奥算法，多准备几张草稿纸。把复杂的文字题目，画成线段图、坐标网格图、甚至画几个圈和方块。图形能够极大地减轻你大脑的记忆负担。
3. 保持好奇心：遇到难题解不出来时，把它当成一个“数字迷宫”。只要不断尝试新的路线，每一次失败都会让你离终点更近一步。

希望这套精心设计的融合讲义，能成为你自学路上的一个好帮手。加油！

—— 本文来自火龙信奥（义乌睿码科技）：义乌青少年信息学奥赛与编程教育平台，专注 CSP-J/S、NOIP、GESP 竞赛培训，线上线下融合教学，助力编程升学。网址：hlcoding.com