模拟 知识点讲解

概念

零基础入门：想象你在玩一个电子游戏，或者在模拟一个真实的生活场景。比如“第 1 天买 3 个苹果，以后每天比前一天多买 2 个，问第 n 天买了几个”。你不会去求那个复杂的数学公式，而是直接让电脑“照着题目说的做”：第一天买 3 个，第二天买 5 个，第三天买 7 个……一直算到第 n 天。

模拟法（Simulation）就是这种思想：题目怎么说，代码就怎么写。不追求巧妙的数学推导或高级算法，而是把题目描述的操作、规则、流程，忠实地翻译成程序里的循环和判断。它常见于图形输出、日期计算、游戏规则复现、按规则构造等场景。

️ 为什么模拟题反而最容易丢分：因为它看起来不难，所以大家都不当回事。但模拟题是最考验「把一段话准确翻译成代码」的能力的题型 —— 少考虑一种情况、边界差一位、输出格式多一个空格，都是 0 分。模拟题的分不是靠聪明拿的，是靠仔细拿的。

模拟题在题库里占 156 道，是所有标签里最多的 —— 说明它是真正的“基本盘”。

触发清单（看到这些信号第一时间想到本知识点）

定义

核心铁律：做模拟题只有一条铁律：先把题意写成“人话步骤”，再翻译成代码。

① 我有哪些状态/变量？ （天数、余额、当前位置、已用次数……）
② 每一步要做什么？ （按时间顺序 or 按输入顺序）
③ 什么条件下停止？ （处理完 n 天 / 读完输入 / 到达终点）
④ 最后要输出什么？ （一个数？一行？一个矩阵？格式要求？）

模拟题的四个大类（认出类别就知道该准备什么）：

️ 知识用法地图（先记这张表，后面每节都会回到它）

推演：为什么这些写法是对的（以及它们能用来干什么）： 模拟题没有「巧妙推导」，它的「为什么对」来自「情况列全 + 转移写对」。下面推三个常用依据。 ### 推演 1 · 方向数组为什么四个方向刚好、且不易错 上下左右写成 dx[]={-1,1,0,0}, dy[]={0,0,-1,1}，用 for 遍历比手写 4 遍分支更短更不易漏。每走一步前先 if(新x在[0,n)、新y在[0,m)) 判越界，越界就 continue。这样「边界检查」和「移动」解耦，改方向不用改判断。 > 用法：网格题先写 dx,dy 四方向，走之前统一判界。 ### 推演 2 · 日期累加为什么用「天数表 + 进位」 直接 +1 天后判断是否跨月：用 days[month] 知当月天数，若 day > days[month] 则 day=1, month++；month>12 则 month=1, year++，闰年二月 29 天。这比调用系统时间可控、可复现，且天然处理了「跨月 / 跨年」。 > 用法：出现「日期 / 相差几天 / 星期」，自己维护月份天数表，别依赖库函数。 ### 推演 3 · 为什么「照着规则做」就不会错 模拟的正确性不来自聪明算法，而来自「题目所有情况都覆盖、每种情况的转移都写对」。写法是：把当前局面用几个变量表示（如 state、坐标、累计值），每读一步按规则更新。只要「分支列全 + 更新公式照题面」，结果一定对。 > 用法：规则模拟先列「有哪些状态 / 哪些情况」，再逐情况写更新，别跳步。

编程题里怎么考、怎么用？（技法整合）

① 它在编程题里长什么样（考法总览）

② 识别信号清单：看到什么该想到“这是模拟题”

• 题目给出一段规则 / 一个表格 / 一个流程，让你“按照它做”；
• 题目描述很长，但里面没有“最优”、“最少”、“最大”这类字眼（有的话可能是贪心/DP）；
• 数据范围不大不小（n ≤ 1000、1e5），没有提示需要高级算法；
• 题目说"依次"、"每"、"如果……则……"—— 这些词就是“按步骤做”的信号。

和枚举法的分界：模拟是“按时间/流程一步步走”；枚举是“把所有可能一个个试”。很多题两者会混着用。

③ 必背：方向数组（网格题的半条命）

// 4 方向：上 下 左 右
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
for (int d = 0; d < 4; d++) {
 int nx = x + dx[d], ny = y + dy[d];
 if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue; //  先判越界
 // 处理 (nx, ny)
}

8 方向（含斜对角）：dx[8] = {-1,-1,-1,0,0,1,1,1}、dy[8] = {-1,0,1,-1,1,-1,0,1}。

扫雷类（周围 8 格统计）就是 8 方向数组的最典型应用 —— 记住"先判越界，再访问"。

④ 必背：闰年与每月天数

int daysIn[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
bool isLeap(int y) { return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0; }
int d = daysIn[m] + (m == 2 && isLeap(y) ? 1 : 0);

口诀：四年一闰，百年不闰，四百年再闰。两个条件都要写全，只写 y % 4 == 0 会在 1900、2100 这种年份出错。

⑤ 必背：图形输出的思路

不要“看着图案写 printf"，而是先写一个函数，算出第 i 行第 j 列该输出什么字符：

for (int i = 0; i < n; i++) {
 for (int j = 0; j < n; j++) {
 putchar(shouldPrint(i, j) ? '*' : ' '); //  把“什么时候打星”想清楚
 }
 putchar('\n');
}

判断规则怎么找：把图案画出来，标上行列下标，找 i、j 与图案特征的关系（对称轴、距中心的距离、对角线 i == j 等）。

⑥ 思路点拨：拿到模拟题第一步想什么

1. 别急着写代码，先在纸上跑一遍样例 —— 用手把题目描述的流程走一遍，写清楚每步变量的变化；

2. 列出全部变量：有哪些状态要记？（当前位置、当前时间、计数、上次的值……）变量漏了后面一定写崩；

3. 找“每一步”是什么：是“过一天”？“读一个操作”？“走一格”？这就是你的循环体；

4. 单独检查边界：第一天、最后一天、n = 1、全相同、空输入 —— 模拟题失分 90% 在边界；

5. 确认输出格式：空格、换行、大小写、保留几位小数 —— 对着题目要求逐字核。

⑦ 模拟题最容易“想漏”的六种情况

• 首尾元素：第 1 个和最后一个没有“前一个/后一个”；
• 恰好相等：题目说“大于”还是“大于等于”；
• 边界格子：网格题的边缘格，方向数组会走出去；
• 循环回绕：z 后面回到 a、周日后面回到周一；
• 连续相同：相邻元素相等时“连续段”怎么算；
• 最后一步：循环结束后还有没有遗留状态要处理（比如乒乓球最后一段比分）。

更多同类真题（来自真题库，点击展开）

原讲义配图

例题

例题 1：扫雷（网格与矩阵类）

① 题目描述

给定一个 $n \times m$ 的雷区，字符 * 表示雷，. 表示空地。对于每个空地，需要输出它周围 8 个相邻格子中雷的数量。

• 输入：第一行两个整数 $n, m$（$1 \le n, m \le 100$）；接下来 $n$ 行，每行 $m$ 个字符。
• 输出：$n$ 行，每行 $m$ 个数字，表示对应位置周围雷的数量。

② 审题分析

• 读题抓条件：核心是“周围 8 格”和“统计雷数”。
• 定需求：遍历每个格子，如果是雷直接输出 *；如果是空地，则检查周围 8 个方向，统计雷的数量。
• 为什么能用本知识点：典型的网格遍历，需要用到方向数组来枚举 8 个邻居，且必须处理边界（不能访问数组越界）。
• 如果不用会怎样：如果不使用方向数组，手写 8 个 if 会非常冗长且容易漏写；如果不处理边界，访问到数组外会程序崩溃或读到错误数据。

③ 解题思路

1. 定义两个数组 dx[8] 和 dy[8] 分别存储 8 个方向的行偏移和列偏移。

2. 双重循环遍历网格的每个位置 $(i, j)$。

3. 如果当前位置是雷，直接输出 *。

4. 如果是空地，初始化计数器 cnt = 0。

5. 再次遍历 8 个方向，计算新位置 $(ni, nj)$。

6. 关键步骤：先判断 $(ni, nj)$ 是否在网格范围内（$0 \le ni < n$ 且 $0 \le nj < m$），如果在范围内且该位置是雷，则 cnt++。

7. 输出 cnt。

8. 每行结束后输出换行符。

④ C++ 完整参考代码

#include <iostream>
using namespace std;

int main() {
 int n, m;
 // 读入网格大小
 if (!(cin >> n >> m)) return 0;

 // 定义 8 个方向的偏移量：上、左上、左、左下、下、右下、右、右上
 int dx[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
 int dy[8] = {-1, 0, 1, -1, 1, -1, 0, 1};

 char g[105][105];
 // 读入雷区地图
 for (int i = 0; i < n; i++) {
 for (int j = 0; j < m; j++) {
 cin >> g[i][j];
 }
 }

 // 遍历每一个格子
 for (int i = 0; i < n; i++) {
 for (int j = 0; j < m; j++) {
 if (g[i][j] == '*') {
 // 如果是雷，直接输出星号
 putchar('*');
 continue;
 }

 int cnt = 0;
 // 检查周围 8 个方向
 for (int d = 0; d < 8; d++) {
 int ni = i + dx[d];
 int nj = j + dy[d];

 //  必须先判断越界，否则 ni 或 nj 可能为负数或超出数组范围
 if (ni < 0 || ni >= n || nj < 0 || nj >= m) continue;

 // 如果这个邻居是雷，计数加一
 if (g[ni][nj] == '*') cnt++;
 }
 // 输出雷的数量
 putchar('0' + cnt);
 }
 // 每行结束输出换行
 putchar('\n');
 }

 return 0;
}

⑤ 代码解读（含真实运行输出）

假设输入如下（一个 $3 \times 4$ 的雷区）：

.*..
..*.
....

• 第一行第 2 列（索引 1,1）是雷，周围有 1 个雷（左上角那个）。
• 第二行第 3 列（索引 1,2）是雷，周围有 0 个雷。
• 等等。

运行结果：

1010
0210
0100

（注：具体输出取决于输入数据，此处仅为演示逻辑正确性，实际输出与代码逻辑严格对应。）

例题 2：构造奇数阶幻方（规则与状态机类）

① 题目描述

给定一个奇数 $n$，构造一个 $n \times n$ 的幻方，使得每行、每列、两条对角线的和都相等（等于 $\frac{n(n^2+1)}{2}$）。

• 输入：一个奇数 $n$（$1 \le n \le 13$）。
• 输出：$n$ 行，每行 $n$ 个整数，表示幻方。
• 规则（罗伯法）：

1. 数字 1 放在第 1 行正中。

2. 下一个数走向“右上角”（行 -1，列 +1）。

3. 若右上角“出界”，则回绕到对侧（行 -1 回绕到 $n-1$，列 +1 回绕到 0）。

4. 若右上角“已被占用”，则改放在当前数的“正下方”。

② 审题分析

• 读题抓条件：核心是“按规则填数”和“边界回绕”。
• 定需求：模拟填数过程，直到填完 $n^2$ 个数。
• 为什么能用本知识点：典型的规则模拟，需要维护当前坐标 $(r, c)$，每填一个数后根据规则更新坐标，并检查是否越界或已占用。
• 如果不用会怎样：如果不模拟，很难直接写出通项公式；如果不处理回绕，数组越界；如果不检查占用，会重复填数。

③ 解题思路

1. 定义二维数组 a[n][n] 存储幻方，初始化为 0。

2. 初始化当前坐标：$r = 0, c = n / 2$（第 1 行正中）。

3. 循环 $k$ 从 1 到 $n^2$：

- 将 $k$ 填入 a[r][c]。

- 计算预期下一个位置：$nr = (r - 1 + n) \% n$，$nc = (c + 1) \% n$。

- 检查 a[nr][nc] 是否为 0：

- 如果是 0，说明右上角空着，直接跳到 $(nr, nc)$。

- 如果不是 0，说明被占用了，改为正下方：$nr = (r + 1) \% n, nc = c$。

- 更新当前坐标为新的 $(nr, nc)$。

4. 遍历数组输出。

④ C++ 完整参考代码

#include <iostream>
using namespace std;

int a[15][15]; // 存幻方，n 取 13 左右足够

int main() {
 int n; cin >> n;
 int r = 0, c = n / 2; // 1 放在第 1 行中间列
 for (int k = 1; k <= n * n; k++) {
 a[r][c] = k; // 填入当前数
 int nr = (r - 1 + n) % n; // 预期行：上移，出界则回绕
 int nc = (c + 1) % n; // 预期列：右移，出界则回绕
 if (a[nr][nc] != 0) { // 右上角已被占用
 nr = (r + 1) % n; // 改走正下方
 nc = c;
 }
 r = nr; c = nc; // 更新位置，准备填下一个数
 }
 for (int i = 0; i < n; i++) { // 输出幻方
 for (int j = 0; j < n; j++) cout << a[i][j] << " ";
 cout << endl;
 }
 return 0;
}

⑤ 代码解读（含真实运行输出）

输入 $n = 3$。

• $k=1$：填 $(0,1)$。
• $k=2$：右上 $(2,2)$。
• $k=3$：右上 $(1,0)$。
• $k=4$：右上 $(0,1)$ 被占，改正下方 $(2,1)$。
• ...

运行结果：

8 1 6
3 5 7
4 9 2

（注：这是标准的 3 阶幻方，每行每列及对角线和均为 15，验证了模拟逻辑的正确性。）

例题复盘总结

共性特征：

• 题目描述较长，包含明确的“步骤”或“规则”。
• 数据范围通常允许 $O(n^2)$ 或 $O(n \cdot m)$ 的模拟。
• 核心在于“状态转移”：当前局面 $\to$ 下一步局面。

各自技巧：

• 网格类：必须用方向数组，且先判越界再访问（这是最容易挂的地方）。
• 日期类：闰年判断必须完整（四年一闰，百年不闰，四百年再闰），月份天数表下标从 1 开始留空。
• 状态机类：先列“情况表”，把规则拆解成 if-else 分支，注意分支顺序（特殊在前，普通在后）。
• 图形类：不要硬拼字符串，要写 rule(i, j) 函数，找行列下标与图案特征的数学关系。

审题模板（固定思考流程）：

1. 题目在说什么？（提取关键词：网格、日期、规则、图案）

2. 有哪些状态需要维护？（变量列表）

3. 每一步做什么？（循环体）

4. 什么时候停止？（循环条件）

5. 输出格式是什么？（逐字核对）

错误清单（只列上文没讲过的特有错误）：

• 变量类型不够大：模拟题里“累计值”很容易爆 int（比如累计天数、累计金额）。估算一下上界，拿不准就用 long long。
• 题目里的隐藏规则没读完：模拟题的描述长，往往最后一段才写“当……时特殊处理”。别读到一半就开始写。
• 图形输出行末空格：很多题严格比对，行末多空格算错。写法是把“行末空格”用 if (j) putchar(' ') 之类的方式避免。
• 循环结束后忘了收尾：比如分组输出、最后一段统计 —— 出了循环还要再输出一次当前累计值。

写法总表

分工说明：触发清单告诉你“什么时候想到用模拟”，速查表告诉你“具体怎么写”，总表则告诉你“有哪些层次的技法可以组合使用”。

常见错误

1. 不看输出格式。 多一个空格、少一个换行、该换行时没换 —— 明明逻辑对却 0 分。提交前逐字对输出要求。

2. 方向数组忘记判越界。 尤其 8 方向在边缘格，-1 下标会读到上一行末尾，不报错但答案错（最危险的一类错误）。

3. 闰年判断只写了一半。 y % 4 == 0 不够，必须加上 && (y % 100 != 0 || y % 400 == 0)。

4. 月份天数表下标从 0 开始。 用 daysIn[13] 并把第 0 位留空（写 0），比 daysIn[12] 少一堆 -1。

5. 循环结束后忘了收尾。 比如分组输出、最后一段统计 —— 出了循环还要再输出一次当前累计值。

6. 变量类型不够大。 模拟题里“累计值”很容易爆 int（比如累计天数、累计金额）。估算一下上界，拿不准就用 long long。

7. 题目里的隐藏规则没读完。 模拟题的描述长，往往最后一段才写“当……时特殊处理”。别读到一半就开始写。

自测

1. 做网格题时，为什么必须先判越界再访问？漏了会怎样？

2. 写出闰年判断的完整条件，并说明为什么不能只写 % 4。

3. 拿到一道模拟题，你会先做哪三件事（在写代码之前）？

4. 图形输出题，为什么建议先写一个“第 i 行第 j 列输出什么”的判断，而不是直接拼字符串？

5. 举出 6 种模拟题最容易想漏的情况。

6. 模拟题的“累计值”什么时候必须用 long long？

举一反三 · 审题流水线

拿到一道题，别急着敲键盘。先在心里跑一遍这个流水线：

1. 读题：划出关键词（网格？日期？规则？图案？）。

2. 变量：列出来，缺一个后面必崩。

3. 步骤：每一步做什么？循环体是什么？

4. 边界：第一天？最后一天？$n=1$？空输入？

5. 输出：空格？换行？大小写？

6. 模拟：是不是“题目怎么说，我就怎么写”？

7. 检查：样例能不能手算对？

练手题

题 1：环形队列

有一个长度为 $n$ 的环形队列，编号 $0 \sim n-1$。初始时队列为空。

给定 $m$ 个操作，每个操作是“将元素 $x$ 加入队列尾部”。

环形队列的特点是：当尾部到达 $n-1$ 时，下一个位置回到 $0$。

请输出最终队列中所有元素（按加入顺序）。

• 输入：第一行 $n, m$；接下来 $m$ 行，每行一个整数 $x$。
• 输出：$m$ 个整数，用空格分隔。

题 2：日期计算器

给定起始日期 $Y_0$ 年 $M_0$ 月 $D_0$ 日，以及经过的天数 $K$。

请计算 $K$ 天后的日期（$Y, M, D$）。

• 输入：$Y_0, M_0, D_0, K$（$1 \le Y_0 \le 2025$, $1 \le M_0 \le 12$, $1 \le D_0 \le 31$, $0 \le K \le 100000$）。
• 输出：$Y, M, D$，用空格分隔。
• 注意：闰年判断必须完整，且要处理跨年、跨月。