当前位置：首页 > news >正文

【NOI】C++算法设计入门之模拟法

news 2025/11/7 16:15:00

文章目录

前言
一、概念
- 1.导入
- 2.概念
- 3.模拟法的步骤
二、例题讲解
- 问题：1074 - 小青蛙回来了
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：1062. 求落地次数
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：2100 - 明明的步行
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：2301 - 药房管理
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：4858 - 自动售货机
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：1241. 角谷猜想
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：2347 - 冰雹猜想
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：1846 - 阿尔法乘积
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：1520 - 骑士的金币（coin）
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：1839 - 龟兔赛跑预测
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：1854 - 寂寞的数
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：2298 - 硬币翻转
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：1468. 小鱼的航程
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
- 问题：1313 - 第n盆花是什么颜色？
- - 1. 问题分析
  - 2. 解题思路
  - 3. 完整代码
三、总结
四、感谢

前言

在算法入门阶段，“模拟法” 是最基础、最实用也最容易上手的核心思想之一。它不需要复杂的数学推导或数据结构支撑，核心是 “按规则复现问题场景”—— 把题目描述的过程、逻辑原封不动地用代码实现，就能得到答案。

学习大纲：C++全国青少年信息学奥林匹克竞赛（NOI）入门级-大纲

一、概念

1.导入

大家听说过” 井底之蛙 “吗？最早出自战国中期思想家庄子所作的《庄子·秋水》。

在这里插入图片描述

有一只青蛙长年住在一口枯井里。它对自己生活的小天地满意极了，一有机会就要当众吹嘘一番。有一天，它吃饱了饭，蹲在井栏上正闲得无聊，忽然看见不远处有一只大海鳖在散步。

青蛙赶紧扯开嗓门喊了起来：“喂，海鳖兄，请过来，快请过来。”

海鳖爬到枯井旁边。

青蛙立刻打开了话匣子：“今天算你运气了，我让你开开眼界，参观一下我的居室。那简直是一座天堂。你大概从来也没有见过这样宽敞的住所吧。”

海鳖探头往井里瞅瞅，只见浅浅的井底积了一摊长满绿苔的泥水，还闻到一股扑鼻的臭味。

海鳖皱了皱眉头，赶紧缩回了脑袋。

青蛙根本没有注意海鳖的表情，挺着大肚子继续吹嘘：“住在这儿，我舒服极了。傍晚可以跳到井栏上乘凉；深夜可以钻到井壁的窟窿里睡觉；泡在水里，让水浸着两腋，托住面颊，可以游泳；跳到泥里，让泥盖没脚背，埋住四足，可以打滚。那些小虫子、螃蟹、蝌蚪什么的，哪一个能比得上我呢。”青蛙唾沫星儿四溅，越说越得意：“瞧，这一坑水，这一口井，都属我一个人所有，我爱怎么样就怎么样。这样的乐趣可以算到顶了吧。海鳖兄，你不想进去观光观光吗。”

在这里插入图片描述

海鳖感到盛情难却，便爬向井口，可是左腿还没能全部伸进去，右腿的就被井栏卡住了。海鳖只能退了回来，青蛙摇摆头。

海鳖说：“大海水天茫茫，无边无际。用千里不能形容它的辽阔，用万丈不能表明它的深度。传说四千多年以前，大禹做国君的时候，十年九涝，海水没有加深；三千多年以前，商汤统治的年代，八年七旱，海水也不见减少。海是这样大，以至时间的长短、旱涝的变化都不能使它的水量发生明显的变化。青蛙弟，我就生活在大海中。你看，比起你这一眼枯井、一坑浅水来，哪个天地更开阔，哪个乐趣更大呢。”

青蛙听傻了，鼓着眼睛，半天合不拢嘴。

于是青蛙就对外面的世界非常好奇，他觉得出去看看。

这才发现，这口井足足有 10 米深，凭它的跳跃能力，根本没法一步跳出去。

好在青蛙没放弃，它观察了一会儿，发现井壁不算太光滑，白天的时候能用爪子抓住岩壁往上爬；可到了晚上，它又累又困，一放松就会顺着岩壁往下滑。

经过几次尝试，小青蛙摸清楚了自己的 “爬井规律”：白天清醒时，它能努力往上爬 3 米，把身体挪到更高的位置；可到了晚上睡觉，身体会不自觉下滑 2 米，一夜过去，又退回去不少。

青蛙心里盘算：“我每天白天爬 3 米、晚上滑 2 米，那是不是每天实际能往上走 1 米？井深 10 米，那 10 天才能爬出去了？”

可真当它开始 “白天爬、晚上滑” 的日子，才发现事情没那么简单 ——

第一天到第七天，重复的 “爬升与滑落”，白天从当前位置往上爬 3 米，晚上睡着后往下滑 2 米；7 天过去，青蛙虽然每天都在 “前进 1 米”，但总共只爬到了 7 米处。

第八天白天爬 3 米后，直接从 7 米到了 10 米，根本没机会滑下去。

假设青蛙爬井变成这样的一个问题，你们会算吗？

它现在每个白天已经可以向上爬 m米了，当然，晚上还是要下滑n米的。如果告诉你井深 h米，请计算一下，现在，它第几天可以爬上来？

如果让你写程序来解决这个问题，你会写吗？

2.概念

模拟法是一种通过模仿问题的实际运行过程或场景来求解问题的算法思想。

将问题陈述中描述的过程、规则或系统，原封不动地、忠实地在计算机中再现一遍，通过计算机的运算能力来得到最终答案。

在这里插入图片描述

模拟法可以说是最直观、最“笨”但也最有效的一种算法思想。

3.模拟法的步骤

分析问题，明确 “过程规则”
- 仔细阅读题目，确保完全理解每一个细节。
- 明确输入是什么，输出是什么。
- 过程的触发条件、终止条件是什么。
- 每一步的操作规则是什么？将文字描述的规则提炼成清晰、无歧义的逻辑步骤。这是最重要的一步！
抽象模型，定义 “数据结构”
- 用变量存储对象属性；
- 用数组记录整体状态。
确定 “初始状态”
- 设置过程的起点。
按规则 “推进过程”
- 循环执行以下操作，直到满足终止条件：
  - 1.读取当前状态；
  - 2.根据规则计算下一步操作；
  - 3.更新状态。
  - 4.检查终止条件：判断是否已经达到模拟结束的条件。
输出 “最终结果”
- 从终止时的状态中提取答案。

二、例题讲解

问题：1074 - 小青蛙回来了

类型：规律循环模拟

题目描述：

关于小青蛙爬井的故事，你应该早就听过了：井深10 尺，小青蛙从井底向上爬，每个白天向上爬 3 尺，每个晚上又滑下来 2 尺，然后问你第几天它能爬上来。答案是第8天。
现在，那只著名的小青蛙又回来了，它现在每个白天已经可以向上爬 m（2≤m≤10 ）尺了，当然，晚上还是要下滑n（1≤n<m）尺的。
如果告诉你井深h（10≤h≤200 ）尺，请计算一下，现在，它第几天可以爬上来。

输入：

有三个整数，分别表示 m、n、h 。

输出：

只有一个整数，表示第几天可以爬上来。

样例：

输入：

3 2 10

输出：

1. 问题分析

已知条件：青蛙白天向上爬 m 尺（2≤m≤10），晚上下滑 n 尺（1≤n<m），井深 h 尺（10≤h≤200）。

目标：计算青蛙从井底爬到井口需要多少天（只要白天爬出井口，就不算晚上下滑）。

假设 m=3（白天爬 3 尺）、n=2（晚上滑 2 尺）、h=10（井深 10 尺），过程如下：

第 1 天：白天爬 3→剩余 7 尺，晚上滑 2→剩余 9 尺（累计 1 天）；
第 2 天：白天爬 3→剩余 6 尺，晚上滑 2→剩余 8 尺（累计 2 天）；
第 3 天：白天爬 3→剩余 5 尺，晚上滑 2→剩余 7 尺（累计 3 天）；
第 4 天：白天爬 3→剩余 4 尺，晚上滑 2→剩余 6 尺（累计 4 天）；
第 5 天：白天爬 3→剩余 3 尺，晚上滑 2→剩余 5 尺（累计 5 天）；
第 6 天：白天爬 3→剩余 2 尺，晚上滑 2→剩余 4 尺（累计 6 天）；
第 7 天：白天爬 3→剩余 1 尺，晚上滑 2→剩余 3 尺（累计 7 天）；
第 8 天：白天爬 3→剩余 0 尺（已爬出），结束（累计 8 天）。

2. 解题思路

核心逻辑是模拟每天的过程，但要注意：最后一天只要白天爬出，就不用算晚上下滑，这是最容易错的点。

步骤拆解：

初始化：用 h 记录剩余井深，day 记录天数（初始 0）。
循环模拟每天：
- 先算白天：青蛙向上爬 m 尺 → 剩余井深 h -= m。
- 检查是否爬出：如果 h ≤ 0（已经到井口或爬出），则天数 +1 后结束（因为不用下滑了）。
- 若没爬出：晚上下滑 n 尺 → 剩余井深 h += n，天数 +1（完整度过一天）。
输出天数：循环结束后，day 就是结果。

3. 完整代码

#include <bits/stdc++.h> // 包含标准库中的所有常用头文件，方便编程但可能影响编译速度
using namespace std; // 使用std命名空间，可以直接调用std下的函数和对象，无需std::前缀int main() { // 程序的主函数// 一、问题分析// 青蛙每天白天爬上m尺，晚上滑下n尺，目标是从深度为h的井中爬出。// 需要计算青蛙需要多少天才能完全爬出井。// 二、数据定义int m, n, h, day = 0; // m: 白天爬升高度, n: 晚上下滑高度, h: 井的深度, day: 青蛙爬出井所花的天数（初始化为0）// 三、数据输入cin >> m >> n >> h; // 从用户输入读取白天爬升高度m、晚上下滑高度n和井的深度h// 四、数据计算while (true) { // 无限循环，直到青蛙爬出井h -= m; // 模拟青蛙白天爬上m尺if (h <= 0) { // 检查青蛙是否达到或超过井口++day; // 青蛙在这一天完全爬出，天数加1break; // 结束循环，青蛙已成功爬出}h += n; // 若未达到，模拟晚上滑下n尺++day;  // 无论是进步还是退步，都算过完一天}// 五、输出结果cout << day; // 输出青蛙爬出井所花的总天数return 0; // 程序执行成功，返回0作为状态码
}

问题：1062. 求落地次数

类型：基础循环模拟

题目描述：

小球从 100 米高处自由落下，着地后又弹回高度的一半再落下。

经过多少次落地后，小球弹起的高度才会低于 0.5 米？

输入：

无。

输出：

一行，一个整数。

1. 问题分析

分析题目要求：小球从 100 米高处自由落下，每次着地后弹回原高度的一半再落下，求弹起高度低于 0.5 米时的落地次数。
确定输入输出：无输入；输出一个整数（落地次数）。
运算规则：每次落地后，弹起高度 = 原高度 ÷ 2；循环此过程，直到弹起高度 < 0.5 米，统计落地次数。

2. 解题思路

整体思路概述：模拟小球 “落下→弹起” 的循环过程，每次落地后更新弹起高度并计数，直到高度低于 0.5 米时终止。
关键步骤说明：
- 初始化：高度 h=100（初始下落高度），计数器 c=0（落地次数）。
- 循环判断：当 h > 0.5 时，执行 “落地→弹起” 操作：
  - 落地一次，c++；
  - 弹起高度更新为 h/2。
- 循环终止后，输出计数器 c。

3. 完整代码

#include <iostream>
using namespace std;int main() {double h = 100; // 初始高度（米）int c = 0;  // 落地次数，初始为0while (h > 0.5) { // 弹起高度高于0.5米时，继续循环c++;      // 落地次数加1h /= 2.0;     // 弹起高度更新为原高度的一半}cout << c << endl;return 0;
}

问题：2100 - 明明的步行

类型：基础循环模拟

题目描述：

小明散步时第一步走 N 厘米，之后每步比前一步少 1 厘米，直到步数为 0 时停下。现给定第一步的长度 N，请计算小明散步的总路程。例如，若 N=3，则总路程为3 + 2 + 1 = 6 厘米。

输入：

输入一个整数 N，代表第一步走的厘米数。

输出：

输出一个整数，代表总共走的厘米数。

样例：

输入：

输出：

1. 问题分析

分析题目要求：计算小明从第一步长度 N 开始，每步递减 1 厘米，直到步数为 0 时的总路程（即求 N + (N-1) + (N-2) + … + 1 的和）。
确定输入输出：输入为整数 N；输出为总路程的整数结果。
运算规则：每步长度 = 前一步长度 - 1，累加所有步数（直到长度为 0 时停止，0 不计入累加）。

2. 解题思路

整体思路概述：通过循环累加从 N 递减到 1 的所有整数，得到总路程。
关键步骤说明：
- 初始化总和变量 s 为 0，输入第一步长度 n。
- 循环条件：当 n > 0 时，将当前 n 累加到 s，然后 n 减 1（模拟下一步长度递减）。
- 循环结束后，输出总和 s。

3. 完整代码

#include<bits/stdc++.h>
using namespace std;
int main(){int n, s = 0; // n：当前步长；s：总路程（初始为0）cin >> n;     // 输入第一步的长度while(n) {    // 当步长大于0时，继续累加s += n;   // 累加当前步长到总路程--n;      // 步长减1，模拟下一步}cout << s;    // 输出总路程return 0;
}

问题：2301 - 药房管理

类型：基础循环模拟

题目描述：

随着信息技术的蓬勃发展，医疗信息化已经成为医院建设中必不可少的一部分。计算机可以很好地辅助医院管理医生信息、病人信息、药品信息等海量数据，使工作人员能够从这些机械的工作中解放出来，将更多精力投入真正的医疗过程中，从而极大地提高了医院整体的工作效率。

对药品的管理是其中的一项重要内容。现在药房的管理员希望使用计算机来帮助他管理。

假设对于任意一种药品，每天开始工作时的库存总量已知，并且一天之内不会通过进货的方式增加。

每天会有很多病人前来取药，每个病人希望取走不同数量的药品。如果病人需要的数量超过了当时的库存量，药房会拒绝该病人的请求。

管理员希望知道每天会有多少病人没有取上药。

输入：

共 3 行
第一行是每天开始时的药品总量 m 。

第二行是这一天取药的人数 n（0<n≤100）。

第三行共有 n 个数，分别记录了每个病人希望取走的药品数量（按照时间先后的顺序），两数之间以空格分隔。

输出：

只有 1 行，为这一天没有取上药品的人数。

样例：

输入：

30
6
10 5 20 6 7 8

输出：

1. 问题分析

分析题目要求：模拟药房一天的取药过程，已知初始药品库存，按时间顺序处理每个病人的取药请求，统计因库存不足未取上药的病人数量。
确定输入输出：
- 输入：3 行数据（第一行初始库存 m；第二行取药人数 n，0<n≤100；第三行 n 个整数，分别为每个病人的取药量）；
- 输出：1 个整数，代表未取上药的病人数。
运算规则：
- 库存初始为 m，一天内不进货（仅减少不增加）；
- 按顺序处理每个病人：若取药量≤当前库存，库存减去取药量（病人取到药）；若取药量 > 当前库存，该病人未取到药（计数 + 1）；
- 无需考虑后续病人，仅按顺序判断当前库存是否满足当前病人需求。

2. 解题思路

整体思路概述：循环遍历每个病人的取药请求，实时更新库存并统计未取上药的人数，核心是 “按顺序模拟取药流程”。
关键步骤说明：
- 初始化变量：初始库存m，取药人数n，未取药人数计数器c=0（初始为 0）。
- 输入数据：读取m、n，再依次读取每个病人的取药量t。
- 循环处理每个取药请求：
  - 若t ≤ m（库存足够），则m -= t（扣减库存）；
  - 若t > m（库存不足），则c++（未取药人数 + 1）。
- 循环结束后，输出计数器c。

3. 完整代码

#include<bits/stdc++.h>
using namespace std;
int main(){int m, n, c = 0; // m：初始药品库存；n：取药人数；c：未取上药的人数（初始0）cin >> m >> n;   // 输入初始库存和取药人数int t; // 临时变量，存储当前病人的取药量for(int i = 1; i <= n; ++i){ // 遍历每个病人cin >> t; // 输入当前病人的取药量if(t <= m){ // 库存足够，病人取到药m -= t; // 库存扣减对应数量} else { // 库存不足，病人未取到药c++; // 未取药人数计数+1}} cout << c; // 输出未取上药的总人数return 0;
}

问题：4858 - 自动售货机

类型：规律循环模拟

题目描述：

有一台售货机，自动售卖玻璃瓶饮料，同时回收空瓶。每 5 个空瓶可以换 2 瓶新的饮料。小蓝刚开始买了 x 瓶饮料，编程计算他最多能喝多少瓶饮料。

例如：

小蓝先买 9 瓶饮料，喝掉 9 瓶，剩 9个空瓶；

拿 5 个空瓶换 2 瓶新的，喝掉 2 瓶，剩 6 个空瓶；

拿 5 个空瓶换 2 瓶新的，喝掉 2 瓶，剩 3 个空瓶；

满 5 个空瓶才能换，不能找别人借瓶子，所以最多能喝 9+2+2=13 瓶

输入：

输入一个整数 x，表示小蓝最初购买的饮料瓶数。

输出：

输出一个整数，表示小蓝最多能喝到的饮料瓶数。

样例：

输入：

输出：

1. 问题分析

分析题目要求：计算小蓝最多能喝到的饮料总瓶数。已知初始购买 x 瓶饮料，每 5 个空瓶可换 2 瓶新饮料（换得的饮料喝完后空瓶可继续参与兑换，且不允许借空瓶）。
确定输入输出：输入为整数 x（初始购买的饮料瓶数）；输出为整数（最多能喝到的总瓶数）。
运算规则：
- 初始喝的瓶数 = 购买的 x 瓶，空瓶数 = x；
- 每次兑换：若空瓶数≥5，可兑换（空瓶数 //5）组，每组换 2 瓶新饮料；
- 兑换后：总喝的瓶数增加 “兑换到的瓶数”，空瓶数更新为 “剩余空瓶（原空瓶 - 兑换用的空瓶）+ 新喝的空瓶（兑换到的瓶数）”；
- 重复兑换直到空瓶数 < 5，停止循环。

2. 解题思路

整体思路概述：模拟 “喝饮料→攒空瓶→兑换新饮料” 的循环过程，累计总喝的瓶数，直到空瓶数不足 5 个无法兑换为止。
关键步骤说明：
- 初始化：总喝的瓶数r = 初始购买量 x，空瓶数k = x（初始喝完 x 瓶后的空瓶）。
- 循环兑换：当空瓶数k ≥ 5时，执行兑换：
  - 用 5 个空瓶换 2 瓶新饮料，总喝的瓶数r += 2；
  - 空瓶数更新：k = (k - 5) + 2（减去兑换用的 5 个，加上新喝的 2 个空瓶）。
- 循环结束后，r即为最多能喝到的总瓶数，输出r。

3. 完整代码

#include<bits/stdc++.h>
using namespace std;
int main(){int x, k, r; // x：初始购买量；k：当前空瓶数；r：总喝的瓶数cin >> x;r = x; // 初始喝了x瓶k = x; // 初始空瓶数为x（喝完x瓶后）x = 0; // 重置x为临时变量，用于存储每次兑换的瓶数// 当空瓶数≥5时，循环兑换while(k >= 5){k -= 5;       // 用5个空瓶兑换x = 2;        // 每次兑换得2瓶新饮料r += x;       // 总喝的瓶数增加2k += x;       // 空瓶数更新（加上新喝的2个空瓶）x = 0;        // 重置临时变量}cout << r; // 输出最多能喝到的总瓶数return 0;
}

问题：1241. 角谷猜想

类型：规律循环模拟

题目描述：

日本一位中学生发现一个奇妙的定理，请角谷教授证明，而教授无能为力，于是产生了角谷猜想。
猜想的内容：任给一个自然数，若为偶数则除以 2 ，若为奇数则乘 3 加 1 ，得到一个新的自然数后按上面的法则继续演算。若干次后得到的结果必为 1 。
请编写代码验证该猜想：求经过多少次运算可得到自然数 1 。
如：输入 22 ，则计算过程为。
22/2=11
11×3+1=34
34/2=17
17×3+1=52
52/2=26
26/2=13
13×3+1=40
40/2=20
20/2=10
10/2=5
5×3+1=16
16/2=8
8/2=4
4/2=2
2/2=1
经过 15 次运算得到自然数 1 。

输入：

一行，一个正整数 n 。（ 1≤n≤20000 )

输出：

一行，一个整数，表示得到 1 所用的运算次数。

样例：

输入：

输出：

1. 问题分析

题目要求：用n按规则变换到1，统计步数。
输入输出：输入正整数n，输出步数（n=1时步数0）。
运算规则：偶数÷2，奇数×3+1。

2. 解题思路

整体思路：用循环模拟，按照角谷猜想的规则一步步对n进行变换，直到n变为1，计数器记步数
关键步骤：
① 初始化n和计数器c（c=0）
② 循环到n=1：判断奇偶→执行变换→c+1
③ 输出c

3. 完整代码

#include <bits/stdc++.h> // 引入C++标准库的头文件，包含大部分常用函数和数据结构
using namespace std; // 使用std命名空间，方便调用其中的标准库函数
int main() {// 分析问题：实现角谷猜想（Collatz Conjecture），即对于任意正整数n，通过特定规则变换，最终都能到达1//1. 已知：一个正整数 n 。（即用户输入的初始数值，是整个问题的起点）//2. 未知：得到 1 所用的运算次数。（即需要计算的结果，是程序最终要输出的值）//3. 关系：模拟法 （通过按照角谷猜想的规则一步步对n进行变换，直到n变为1，同时记录变换的次数，以此得到未知结果）int n; // 定义变量n，用于存储用户输入的初始数值（对应“已知”中的正整数n）// 数据输入：获取已知条件（用户输入的正整数n）cin >> n;// 数据计算：根据“关系”中的模拟法，求解未知结果（运算次数）int c=0; // 定义计数器c并初始化为0，用于记录运算次数（对应“未知”的结果）while(n!=1){ // 循环执行变换，直到n变为1（停止条件，此时已得到目标）if(n%2==0){ // 若n是偶数，按照角谷猜想规则执行变换：n变为n/2n/=2;}else{ // 若n是奇数，按照角谷猜想规则执行变换：n变为3n+1n=n*3+1;    }++c; // 每完成一次变换，计数器加1（累计运算次数，逐步接近未知结果）}// 输出结果：将计算得到的“未知”结果（运算次数c）输出cout << c; return 0; // 程序正常结束，返回0
}

问题：2347 - 冰雹猜想

类型：规律循环模拟

题目描述：

70 年代中期，美国各所名牌大学校园内，人们都废寝忘食地玩一种数学游戏：冰雹猜想。

这个游戏十分简单，任意写出一个正整数 n，按照以下规则变换直到变为 1：

若 n 是奇数，则下一步为 3n + 1；

若 n 是偶数，则下一步为 n/2。

要求输入一个正整数 n，输出其从 n 变换到 1 的完整过程。

例如，当 n=5 时，变换过程为：16，8，4，2，1。

输入：

输入一行，一个正整数 n(1 < n < 1000）。

输出：

输出若干行，顺序输出整数 n 变换到 1 的处理过程，每行输出一步变换的表达式。

样例：

输入：

输出：

6/2=3 
3*3+1=10 
10/2=5 
5*3+1=16 
16/2=8 
8/2=4 
4/2=2 
2/2=1

1. 问题分析

分析题目要求：模拟冰雹猜想的变换过程，输出从输入的正整数 n 到 1 的每一步变换表达式。
确定输入输出：输入为正整数 n(1 < n < 1000）；输出为每一步的变换表达式，直到 n=1。
运算规则：若 n 是奇数，下一步为 (3n + 1)；若 n 是偶数，下一步为 (n/2)；循环此过程直到 (n=1)。

2. 解题思路

整体思路概述：循环模拟冰雹猜想的变换过程，每一步判断 n 的奇偶性，输出对应的变换表达式，然后更新 n，直到 (n=1) 时终止循环。
关键步骤说明：
输入正整数 n。循环条件为 (n !=1)：
- 若 n 是偶数，计算下一步 (n/2)，输出格式为 (n/2=结果)，并更新 n 为该结果。
- 若 n 是奇数，计算下一步 (3n + 1)，输出格式为 (n*3+1=结果)，并更新 n 为该结果。
每次输出后换行，循环直到 (n=1) 时结束。

3. 完整代码

#include<bits/stdc++.h>
using namespace std;
int main(){int n;cin >> n; // 输入初始正整数nwhile(n != 1){ // 循环直到n变为1if(n % 2 == 0){ // 偶数情况int next = n / 2;cout << n << "/2=" << next << endl;n = next;} else { // 奇数情况int next = n * 3 + 1;cout << n << "*3+1=" << next << endl;n = next;}} return 0;
}

问题：1846 - 阿尔法乘积

类型：规律循环模拟

题目描述：

计算一个整数的阿尔法乘积。规则为：若整数是个位数，其阿尔法乘积为自身；否则，计算其各位非 0 数字的乘积，再对该乘积递归执行此操作，直到得到个位数。

例如，4018224312的阿尔法乘积计算过程为：4×1×8×2×2×4×3×1×2→3072→3×7×2→42→4×2→8，最终结果为8。

编写一个程序，输入一个正整数（该整数的值在 int 范围内），输出它的阿尔法乘积。

输入：

输入一行，一个正整数（值在int范围内）。

输出：

输出一行，一个整数，即该数的阿尔法乘积。

样例：

输入：

输出：

1. 问题分析

分析题目要求：对输入的正整数，递归计算其各位非 0 数字的乘积，直到结果为个位数，输出最终结果。
确定输入输出：输入为一个正整数；输出为其阿尔法乘积（个位数）。
运算规则：若数大于 9，分解其各位数字，将非 0 数字相乘得到新数；重复此过程，直到数为个位数。

2. 解题思路

整体思路概述：循环处理输入的数，每次分解其各位非 0 数字并相乘，更新原数，直到原数为个位数时输出。
关键步骤说明：
- 输入正整数n。
- 外层循环判断n是否大于 9：若大于，进入内层循环分解n的各位数字。
- 内层循环中，对n逐位取余（n%10），若数字非 0 则累乘到临时变量r，然后n除以 10（n/=10）。
- 内层循环结束后，将r赋值给n，重复外层循环判断，直到n为个位数。
- 输出最终的n。

3. 完整代码

#include<bits/stdc++.h>
using namespace std;
int main(){int n;cin>>n;// 循环处理，直到n为个位数while(n>9){int r=1; // 临时存储各位非0数字的乘积// 分解n的各位数字while(n){if(n%10!=0) r*=n%10; // 非0数字才参与乘积n/=10; // 去掉已处理的最后一位}n=r; // 更新n为新的乘积结果}cout<<n;return 0;
}

问题：1520 - 骑士的金币（coin）

类型：复杂流程模拟

题目描述：

国王将金币作为奖励，发放给忠诚的骑士。

第一天，骑士收到一枚金币；之后两天（第二天和第三天）里，每天收到两枚金币；之后三天（第四、五、六天）里，每天收到三枚金币；之后四天（第七、八、九、十天）里，每天收到四枚金币 … 这种工资发放模式会一直这样延续下去：当连续 N 天每天收到 N 枚金币后，骑士会在之后的连续 N+1 天里，每天收到 N+1 枚金币（ N 为任意正整数）。

你需要编写一个程序，确定从第一天开始的给定天数内，骑士一共获得了多少金币。

输入：

一个整数（范围 1-10000），表示天数。

输出：

骑士获得的金币数。

样例：

输入：

输出：

1. 问题分析

分析题目要求：计算骑士在给定天数内获得的总金币数。金币发放规则为：第 1 天 1 枚；接下来 2 天每天 2 枚；接下来 3 天每天 3 枚；以此类推（即连续 k 天每天发 k 枚，之后连续 k+1 天每天发 k+1 枚，k 为正整数）。
确定输入输出：输入为 1-10000 的整数（表示天数）；输出为骑士在这些天内获得的金币总数。
运算规则：按 “阶段” 发放金币：第 1 阶段（1 天）每天 1 枚，第 2 阶段（2 天）每天 2 枚，第 3 阶段（3 天）每天 3 枚…… 第 k 阶段持续 k 天，每天发 k 枚，直到覆盖给定的所有天数。

2. 解题思路

整体思路概述：模拟每天的金币积累过程，按阶段跟踪当前每天的金币数和剩余天数，累加每个阶段内（或阶段部分天数）的金币，直到覆盖所有输入的天数。
关键步骤说明：
- 初始化变量：总金币数s=0，当前阶段每天金币数d=1（从第 1 阶段开始），当前阶段剩余天数t=1（第 1 阶段持续 1 天）。
- 循环遍历每一天（从 1 到输入的天数n）：
  - 累加当天金币（s += d）。
  - 当前阶段剩余天数减 1（t–）。
  - 若当前阶段剩余天数为 0（t==0），进入下一个阶段：d加 1（下阶段每天金币数），t更新为d（下阶段持续天数）。
- 循环结束后，s即为总金币数，输出即可。

3. 完整代码

#include<bits/stdc++.h>
using namespace std;
int main(){int n, s = 0; // n：输入的天数；s：总金币数（初始为0）cin >> n;int t = 1; // 当前阶段剩余的天数（初始为第1阶段，剩余1天）int d = 1; // 当前阶段每天的金币数（初始为第1阶段，每天1枚）for(int i = 1; i <= n; ++i){ // 遍历每一天s += d; // 累加当天的金币t--;    // 当前阶段剩余天数减1// 若当前阶段天数用完，进入下一个阶段if(t == 0){d++; // 下阶段每天金币数+1t = d; // 下阶段持续天数等于下阶段的金币数}}cout << s; // 输出总金币数return 0;
}

问题：1839 - 龟兔赛跑预测

类型：复杂流程模拟

题目描述：

话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先 t 米或以上，它们就会停下来休息 s 秒。对于不同的兔子，t，s 的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。

然而有些比赛相当漫长，全程观看会耗费大量时间，而小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度 v1（表示每秒兔子能跑 v1 米），乌龟的速度 v2 ，以及兔子对应的 t，s值，以及赛道的长度 l ——就能预测出比赛的结果。但是小华很懒，不想通过手工计算推测出比赛的结果，于是他找到了你——清华大学计算机系的高才生——请求帮助，请你写一个程序，对于输入的一场比赛的数据 v1 ，v2 ，t，s，l，预测该场比赛的结果。

输入：

输入只有一行，包含用空格隔开的五个正整数 v1 ，v 2 ，t，s，l，其中(v 1 ,v 2 ≤100;t≤300;s≤10;l≤10000 且为 v 1 ,v 2的公倍数)

输出：

输出包含两行，第一行输出比赛结果——一个大写字母 T 或 R 或 D，分别表示乌龟获胜，兔子获胜，或者两者同时到达终点。

第二行输出一个正整数，表示获胜者（或者双方同时）到达终点所耗费的时间（秒数）。

样例1：

输入：

10 5 5 2 20

输出：

D
4

样例2：

输入：

10 5 5 1 20

输出：

R
3

样例3：

输入：

10 5 5 3 20

输出：

T
4

1. 问题分析

分析题目要求：模拟龟兔赛跑过程，根据两者的速度、兔子的休息规则（领先 t 米及以上则休息 s 秒），预测比赛结果（乌龟胜 T / 兔子胜 R / 同时到达 D）及所用时间。
确定输入输出：
- 输入：5 个正整数（v1：兔子速度，v2：乌龟速度，t：兔子休息阈值，s：休息时长，l：赛道长度）；
- 输出：第一行为结果（T/R/D），第二行为比赛总时间（秒）。
运算规则：
- 每秒内：兔子跑 v1 米，乌龟跑 v2 米（正常情况）；
- 若任一秒结束后，兔子距离 - 乌龟距离 ≥ t，兔子将休息 s 秒（期间兔子不动，乌龟每秒跑 v2 米）；
- 当一方或双方到达终点（距离≥l）时，比赛结束。

2. 解题思路

整体思路概述：循环模拟比赛的每一秒（或休息时段），实时更新兔子和乌龟的距离及时间，直到有一方到达终点，最后比较双方距离确定结果。
关键步骤说明：
- 初始化变量：兔子距离st=0，乌龟距离sg=0，时间m=0。
- 循环条件：当双方均未到达终点（st < l且sg < l）时，持续模拟：
  - 正常跑 1 秒：兔子跑 v1 米，乌龟跑 v2 米，时间 + 1。
  - 检查是否结束：若此时任一方到达终点，跳出循环。
  - 判断兔子是否休息：若兔子领先≥t 米，进入休息流程：
    - 兔子休息 s 秒，期间乌龟每秒跑 v2 米，时间每秒 + 1；
    - 每休息 1 秒后检查乌龟是否到达终点，若到达则提前结束休息。
- 循环结束后，比较双方距离：
  - 兔子距离 > 乌龟距离→R；
  - 乌龟距离 > 兔子距离→T；
  - 相等→D，输出结果和时间。

3. 完整代码

#include<bits/stdc++.h>
using namespace std;
int main(){int v1, v2, t, s, l;cin >> v1 >> v2 >> t >> s >> l;int st = 0; // 兔子跑的总距离int sg = 0; // 乌龟爬的总距离int m = 0;  // 比赛总时间（秒）// 循环模拟，直到一方或双方到达终点while (!(st >= l || sg >= l)) {// 正常跑1秒：兔子和乌龟各前进一段距离，时间+1st += v1;sg += v2;m++;// 检查这1秒后是否已有一方到达终点，若有则结束模拟if (st >= l || sg >= l) break;// 若兔子领先t米及以上，进入休息流程if (st - sg >= t) {// 兔子休息s秒，期间乌龟继续前进for (int i = 1; i <= s; ++i) {sg += v2; // 乌龟每秒前进v2米m++;      // 时间+1// 若休息期间乌龟到达终点，提前结束休息if (sg >= l) break;}}}// 判断比赛结果并输出if (st > sg) {cout << "R" << endl << m;} else if (st < sg) {cout << "T" << endl << m;} else {cout << "D" << endl << m;}return 0;
}

问题：1854 - 寂寞的数

类型：标记类模拟

题目描述：

道德经曰：一生二，二生三，三生万物。

对于任意正整数n，我们定义d(n)的值为n加上组成n的各个数字的和。

例如d(23)=23+2+3=28，d(1481)=1481+1+4+8+1=1495。

因此，给定了任意一个n作为起点，你可以构造如下一个递增序列:n,d(n),d(d(n)),d(d(d(n)))…例如，从33开
始的递增序列为:33 39,51 57,69,84,96,111,114,120,123,129,141…

我们把n叫做d(n)的生成元，在上面的数列中，33是39的生成元，39是51的生成元，等等。有一些数字甚至可以有两个生成元，比如101，可以由91和100生成。但也有一些数字没有任何生成元；如42，我们把这样的数字称为寂寞的数字。

输入：

一行，一个正整数n。（n<=10000）

输出：

按照升序输出小于n的所有寂寞的数字，每行一个。

样例：

输入：

输出：

1. 问题分析

分析题目要求：找出所有小于输入整数n的 “寂寞的数”。寂寞的数定义为：不存在任何正整数k作为其生成元的数（生成元k满足d(k) = 该数，其中d(k) = k + 组成k的各个数字之和）。
确定输入输出：输入为一个正整数n（n ≤ 10000）；输出为所有小于n的寂寞的数，按升序排列，每行一个。
运算规则：
- 生成元公式：对于任意正整数k，d(k) = k + （k的各位数字之和）；
- 若存在k使得d(k) = x，则x有生成元，不是寂寞的数；否则x是寂寞的数。

2. 解题思路

整体思路概述：先通过循环计算所有可能的生成元k对应的d(k)，标记这些d(k)为 “有生成元”；再遍历小于n的所有数，输出未被标记的数（即寂寞的数）。
关键步骤说明：
- 初始化标记数组：定义数组a（大小足够覆盖可能的d(k)），用于标记数字是否有生成元（初始值为 0，代表无生成元）。
- 计算并标记有生成元的数：循环k从 1 到n（因为d(k) > k，若k ≥ n，d(k)必然≥n，无需考虑）：
  - 计算d(k)：k加上其各位数字之和；
  - 若d(k) < n，则标记a[d(k)] += 1（表示d(k)有生成元）。
- 输出寂寞的数：遍历 1 到n-1，若a[x] == 0（无生成元），则输出x。

3. 完整代码

#include<bits/stdc++.h>
using namespace std;
int a[10010] = {0}; // 标记数组：a[x]为0表示x是寂寞的数（无生成元）int main(){int n;cin >> n;// 步骤1：计算所有可能的生成元k对应的d(k)，并标记有生成元的数for(int k = 1; k <n; ++k){ // k为可能的生成元，范围1到n-1（d(k) >k，k>=n时d(k)>=n）int t = k; // 临时变量存储k，用于拆分各位数字int d = k; // d(k)的初始值为k// 计算k的各位数字之和，累加至dwhile(t > 0){d += t % 10; // 取末位数字并累加t /= 10;     // 移除末位数字}// 若d(k)小于n，则标记d为有生成元if(d < n){a[d]++; // 至少有一个生成元，计数+1}}// 步骤2：输出所有小于n的寂寞的数（a[x]为0的数）for(int x = 1; x < n; ++x){if(a[x] == 0){cout << x << endl;}}return 0;
}

问题：2298 - 硬币翻转

类型：嵌套循环模拟

题目描述：

假设有 N 个硬币(N为不大于5000的正整数)，从1到N按顺序依次编号，初始时全部处于正面向上的状态；有M个人(M为不大于N的正整数)也从1到M依次编号。第一个人（1号）将硬币全部翻转一次，第二个人（2号）将编号为2的倍数的硬币翻转一次，第三个人（3号）将编号为3的倍数的硬币翻转一次。依照编号递增顺序，以后的人都和3号一样，将凡是自己编号倍数的硬币翻转一次。
请问：当第M个人操作之后，哪些硬币是正面向上的，按从小到大输出其编号，以空格分开。

输入：

输入正整数N和M，以单个空格隔开

输出：

顺次输出正面向上的硬币的编号，其间用空格间隔。

样例：

输入：

10 10

输出：

2 3 5 6 7 8 10

1. 问题分析

分析题目要求：有 N 个初始正面向上的硬币（编号 1~N），M 个人（编号 1~M）依次操作：第 i 人翻转所有编号为 i 的倍数的硬币。需找出第 M 人操作后仍正面向上的硬币编号。
确定输入输出：输入为两个正整数 N（硬币数，≤5000）和 M（人数，≤N）；输出为正面向上的硬币编号，按升序用空格分隔。
运算规则：
- 硬币初始状态：正面向上（翻转 0 次）。
- 第 i 人操作：翻转所有编号是 i 的倍数的硬币（翻转次数 + 1）。
- 最终状态：翻转次数为偶数→正面向上（奇数次→反面向上）。

2. 解题思路

整体思路概述：模拟 M 个人翻转硬币的过程，统计每个硬币被翻转的次数，最后筛选出翻转次数为偶数的硬币编号。
关键步骤说明：
- 初始化计数数组：定义数组a（大小 N+1），a[j]表示第 j 号硬币被翻转的次数（初始为 0）。
- 模拟翻转过程：嵌套循环实现 M 个人的操作：
  - 外层循环遍历每个人（i 从 1 到 M）；
  - 内层循环遍历所有硬币（j 从 1 到 N），若 j 是 i 的倍数（j%i==0），则a[j]++（翻转次数 + 1）。
- 筛选正面向上的硬币：遍历 1~N 号硬币，若a[j]为偶数（翻转次数偶数），则输出 j。

3. 完整代码

#include<bits/stdc++.h>
using namespace std;
int main(){int n, m;int a[5010] = {0}; // a[j]记录第j号硬币被翻转的次数（初始0）cin >> n >> m;// 模拟M个人翻转硬币的过程for(int i = 1; i <= m; ++i){ // 第i个人for(int j = 1; j <= n; ++j){ // 遍历所有硬币if(j % i == 0){ // 若硬币j是i的倍数，翻转它（次数+1）a[j]++;}}}// 输出翻转次数为偶数的硬币（正面向上）for(int i = 1; i <= n; ++i){if(a[i] % 2 == 0){cout << i << " ";}}return 0;
}

问题：1468. 小鱼的航程

类型：需要找规律的循环

题目描述：

有一只小鱼，它上午游泳150公里，下午游泳100公里，晚上和周末都休息（实行双休日)，假设从周x(1<=x<=7)开始算起，请问这样过了n天以后，小鱼一共累计游泳了多少公里呢？

输入：

输入两个整数x,n(表示从周x算起，经过n天，x是1~ 7之间的整数，n是0~1000之间的整数）。

输出：

输出一个整数，表示小鱼累计游泳了多少公里。

样例：

输入：

3 10

输出：

1. 问题分析

已知条件：从周x开始，持续n天；工作日（周一～周五）上午游 150km、下午游 100km（每天共 250km），周末（周六、周日）休息。

目标：计算n天内小鱼累计游泳的总公里数。

示例：若x=1（周一）、n=3天：

第 1 天（周一）：250km → 累计 250；
第 2 天（周二）：250km → 累计 500；
第 3 天（周三）：250km → 累计 750；

最终输出750。

2. 解题思路

整体思路：循环遍历n天，逐天判断是否为周末，非周末则累加 250km，同时更新 “周几” 的状态。

关键步骤：

初始化变量：x（开始周几）、n（总天数）、s（累计公里数，初始为 0）。
循环n次，模拟每一天：
- 若当前是周六：x++（进入周日），跳过当天（不游泳）；
- 若当前是周日：x=1（跳转到周一），跳过当天（不游泳）；
- 若为工作日：s += 250（累加当天游泳距离），x++（进入下一天）。

循环结束后，输出累计公里数s。

3. 完整代码

#include<bits/stdc++.h> // 引入标准库，包含常用的数据结构和算法
using namespace std; // 使用std命名空间，简化对标准库中元素的调用int main(){ // 程序的主入口函数// 一、分析问题// 给定小鱼从周x开始游泳，持续n天，需要计算这n天里小鱼总共游泳了多少公里。// 小鱼的工作日（周一到周五）上午游泳150公里，下午游泳100公里；周末不游泳。// 二、数据定义int x,n,s=0; // x: 开始游泳的周几, n: 总共游泳的天数, s: 累计游泳的总距离(初始为0)// 三、数据输入cin>>x>>n; // 从用户处读取开始游泳的周几（x）和总天数（n）// 四、数据计算for(int i=1; i<=n; i++){ // 遍历从第一天到第n天// 如果当前是周六或周日，则日期加1进入下一天（周末不游泳）if(x==6){ ++x; continue; // 跳过本次循环的剩余部分，直接开始下一次循环}if(x==7){ x=1; // 周日过后回到周一continue;}// 非周末，每天游泳总距离为250公里（上午+下午）s += 250; // 累加到总距离s中++x;      // 日期递增，模拟到下一天}// 五、输出结果cout<<s; // 输出小鱼累计游泳的总距离return 0; // 主函数正常结束，返回0表示成功
}

问题：1313 - 第n盆花是什么颜色？

类型：周期规律模拟类问题

题目描述：

学校操场上摆放了 m 组花排成了一排，每组花有 3 盆颜色分别是蓝花、黄花、红花。小芳和同学们开始玩一个游戏，从第一盆花开始数数，当数到 n 的时候让同学们来计算他面前的是什么颜色的花。如果数到最后一盆了，就倒过来往前数。

例如：有 3 组花，小芳数到了 8 ，就是倒数第二盆黄花（3 组花有 9 盆）；小芳数到了 9 就是最后一盆红花；小芳数到 10 ，又回到倒数第二盆黄花。

输入：

两个整数 m 和 n （m 和 n 都是 1∼1000000 之间的整数），m 代表总共有多少组花，n 代表小芳数到的数字。

输出：

花的颜色，输出它们颜色的拼音，如：lan、huang、hong。

样例：

输入：

3 10

输出：

huang

1. 问题分析

分析题目要求：已知有m组花，每组 3 盆（颜色依次为蓝、黄、红），按 “正向排列→反向折返” 的规律循环。需确定第n盆花的颜色（蓝→lan，黄→huang，红→hong）。
例如：3 组花共 9 盆（正向 1-9），之后倒着数（8-2），再正向（3-9），形成循环。
确定输入输出：输入为两个整数m（组数，1≤m≤1e6）和n（第 n 盆，1≤n≤1e6）；输出为对应颜色的拼音。
运算规则：
- 正向排列：1 到3m盆，每组顺序为蓝（1st）、黄（2nd）、红（3rd）。
- 反向折返：从3m-1倒回 2 盆（即3m之后是3m-1，再3m-2，…，直到 2）。
- 循环周期：正向3m盆 + 反向3m-2盆 = 6m-2盆（一个完整周期的长度）。

2. 解题思路

整体思路概述：先通过取模运算将n映射到一个周期内（简化计算），再判断其在周期内的位置（正向或反向），最后根据位置确定颜色。
关键步骤说明：
- 计算周期长度：一个完整周期包含6m-2盆花（正向3m盆 + 反向3m-2盆）。
- 映射n到周期内：k = n % (6m-2)，若k=0则k=6m-2（避免 0 值，确保对应最后一位）。
- 判断正向 / 反向：
  - 若k ≤ 3m：处于正向，直接用k的位置判断颜色（k%3：1→蓝，2→黄，0→红）。
  - 若k > 3m：处于反向，此时k对应反向位置，其颜色规律与正向对称（k%3：1→黄，2→蓝，0→红）。

模拟思想的本质是 “用代码复现问题的逻辑流程”，而不是形式上的 “逐步骤循环”。通过分析周期、映射范围、分阶段处理，精准复现了花的排列规律，是模拟思想的应用。

3. 完整代码

#include<bits/stdc++.h>
using namespace std;
int main(){int m, n;cin >> m >> n;int cycle = 6 * m - 2; // 一个完整周期的长度n %= cycle; // 将n映射到一个周期内if (n == 0) n = cycle; // 若余数为0，对应周期的最后一个位置if (n <= 3 * m) { // 正向位置if (n % 3 == 1) {cout << "lan";} else if (n % 3 == 2) {cout << "huang";} else {cout << "hong";}} else { // 反向位置（对称规律）if (n % 3 == 1) {cout << "huang";} else if (n % 3 == 2) {cout << "lan";} else {cout << "hong";}}return 0;
}