年关的奇妙构思

模式 1：分段判断（选择结构）#

1
if (条件1) {
2
    ...
3
}
4
else if (条件2) {      /* ← 必须是 else if，不能是独立 if */
5
    ...
6
}
7
else {                 /* 兜底 */
8
    ...
9
}

要点：分支互斥时一定用 else if 链。

模式 2：累加器（求和/求平均）#

1
long long sum = 0;                      /* ① 先清零 */
2
for (i = 0; i < n; i++) {
3
    scanf("%d", &x);
4
    sum += x;                           /* ② 累加 */
5
}
6
printf("%lld\n", sum);                  /* ③ 输出 */

要点：sum 必须清零；防溢出用 long long。

模式 3：计数器（数个数）#

1
int cnt = 0;                            /* 先清零 */
2
for (...) {
3
    if (满足条件) cnt++;                /* 命中才 +1 */
4
}

模式 4：打擂台（求最值）#

1
int max = 第一个数;                     /* ① 立擂主，不能用 0！ */
2
for (...) {
3
    scanf("%d", &x);
4
    if (x > max) max = x;               /* ② 严格 > ，平手不换 */
5
}

要点：

• 初值不能给 0（除非确定有非负数）
• 用严格 > → 平手时保留先出现的

模式 5：判断某性质（试除/逐位处理）#

1
/* 例：判断质数 */
2
int isPrime = 1;
3
for (i = 2; i * i <= n; i++) {          /* 试到开方就够 */
4
    if (n % i == 0) { isPrime = 0; break; }
5
}
6

7
/* 例：逐位处理（水仙花数、求位数） */
8
while (n > 0) {
9
    int d = n % 10;                     /* 取最后一位 */
10
    ...
11
    n /= 10;                            /* 砍掉最后一位 */
12
}

A. 标点符号类（最高频！）#

自查方法：提交前数一遍 { 和 }；检查每个 if (...)、while (...) 右括号后有没有多余分号。

B. 分支结构类#

C. 循环结构类#

D. 变量与类型类#

E. 输出格式类（吃过亏！）#

铁律：题目要求输出什么，就一个字符不差地照抄。

F. 数学/业务理解类#

★★ 两题的”最大值”对比：次数知不知道，决定用 for 还是 while#

哨兵值（结束标志）#

哨兵值 = 一个特殊的数，它不是数据本身，只负责站在队尾喊”到此为止”。

1
   7   6   5   9   2   -1
2
   ↑                   ↑
3
  真成绩 ────────────── 真成绩   哨兵（不是成绩！）

循环条件问的是”手上这个数还是有效数据吗”（x >= 0），不是”是不是哨兵”（x != -1）。 后者只在哨兵恰好是 -1 时才对 —— 万一哨兵是 -5 就漏了。

为什么不需要专门排除哨兵： 读到 -1 时，while (x >= 0) 立刻不成立，循环体一次都不执行，哨兵根本没机会参加打擂台。

不定项输入的标准摆法（推荐背下来）：

1
scanf("%d", &x);          /* 起点：先读一个 */
2
max = x;                  /*       让它先当擂主 */
3
while (x >= 0) {          /* 条件：手上这个还是有效数据吗 */
4
    if (x > max) max = x;
5
    scanf("%d", &x);      /* 更新：读下一个  ← ★ 最容易忘的一句 */
6
}
7
printf("%d\n", max);      /* 输出：循环【外面】 */

两种”输入结束”的区别：

紧凑写法（把 scanf 塞进条件）：

1
int x, max = -1;                        /* 成绩非负，-1 比任何成绩都小 */
2
while (scanf("%d", &x) == 1 && x >= 0)
3
    if (x > max) max = x;
4
printf("%d\n", max);

顺序不能换：scanf(...) == 1 必须在 && 前面（先确认读到了，再看值）。

★ 正序拆位：位权 h 三件套（第 37 题）#

第 36 题是个位优先（逆序），第 37 题是最高位优先（正序）。方向反了，做法就变了。

位权 = 这一位代表多少个 1。 12345 的位权依次是 1 / 10 / 100 / 1000 / 10000。

第一步：找最高位的位权。

1
int h = 1;
2
while (n / h >= 10)     /* 问：n/h 还是两位数以上吗？是就再升一级 */
3
    h = h * 10;

⚠️ 必须写 n / h >= 10，不能写 n / h > 0 —— 后者会多乘一次 10，位权多一个 0，输出前面多一个 0。

⚠️ 也别写 h * 10 <= n —— 本题范围（n ≤ 10^9）内能过，但 n 接近 int 上限时 h * 10 会溢出绕圈，最后 h 变成 0 → n / h 除以零，程序直接崩溃（退出码 -1073741676 = 0xC0000094）。能用除法判断就别用乘法。

第二步：从高位到低位逐位吐。

1
while (h > 0) {
2
    printf("%d ", n / h);   /* ① 吐出最高位 */
3
    n = n % h;              /* ② ★ 把最高位削掉（漏了就会吐"前缀"）*/
4
    h = h / 10;             /* ③ 位权降一级 */
5
}

②和③是一对，缺一不可：

• 少了 n = n % h → 吐出来的是越来越长的前缀（1 12 123 1234 12345）
• 少了 h = h / 10 → 死循环，一直吐同一个数字

为什么少了②会变成前缀：n / h 的含义是”把低 h 位砍掉，留下高位部分”。不把刚吐出的那一位削掉，下一轮除数小 10 倍，就多露出前面一位。

记忆法：想「留下」最高位用 /（取商），想「扔掉」最高位用 %（取余）。

⚠️ 拆位会把 n 改掉。 循环结束后 n 已经变成 0，原值丢了。如果后面还要用 n，必须在拆位之前先备份 int m = n; —— 而且这句必须写在 scanf 之后！

实测对照（缺口那一行 vs 补上）：

复发错误榜（按次数排序，提交前必查）#

★ 铁律：题目里出现”注意：…”，就当它是一行必须写的代码#

第 33 题题面写着 “注意：1不是素数”，他代码里没有这一行 → 1000 个测试点错 1 个 → 报错。 第 34 题题面写着 “提示：注意计算过程中的类型溢出问题” → 他按要求用了 long long → 一次通过。

第 34 题题面写着 “提示：注意计算过程中的类型溢出问题” → 他按要求用了 long long → 一次通过。 第 37 题题面写着 “提示：注意整数运算避免使用 double 类型的函数如 pow()“，并且直接把算法给了出来 → 他没写 pow，用整数循环找位权，while (n/wei>=10) 第一版就写对了。

而且第 37 题他是自己主动说出”这次竟然还有提示”的 —— 说明这条铁律已经养成。

题目不会白写废话。凡是”注意""提示""保证""规定”后面的内容，都要落到代码里。

★ 写赋值语句前先问一句：“右边的量，现在有值了吗？”#

同一个错误犯了两次（第 28 题、第 37 题），必须单列出来。

规则：凡是”把某个变量备份/初始化到另一个变量”，那一行必须写在”数据读进来之后”。

拆位/递推题的三个雷区（第 37 题一轮全踩）：

递推三连问（每次写 递推 + 累加 都要问）#

1. 我这一步用的是”上一项”吗？（阶乘漏了 *i、写成 (jiecheng-1)*jiecheng）
2. 递推语句放在”加”的前面还是后面？配得上变量的初值吗？（第 29 题两行反了）
3. 变量初值对吗？（fact=1 不是 0；term=0 不是 a；x=item 要等 scanf 之后）

三个必须区分的”递推家族”#

二阶递推的固定写法（滚动变量 / 滑动窗口）：

1
int a = 1, b = 1;              /* 窗口最初盖住第1、2项 */
2
for (i = 1; i < n; i++) {      /* 滚 n-1 次 */
3
    int t = a + b;             /* 先算新项存到临时变量 */
4
    a = b;                     /* a 右移 */
5
    b = t;                     /* b 右移 */
6
}
7
printf("%d\n", a);

关键：a = b; b = t; 必须借助临时变量 t，绝不能写成 a = b; b = a + b;（前一项被覆盖）。

逆推题的固定三问：

1. 起点是什么？（已知的最后一项）
2. 翻几次？（“已知末项求首项”→ 几乎总是 n-1 次）
3. 怎么翻？（把题目条件反解成公式）

while 还是 for？—— 看”次数知不知道”#

两者完全等价：for (A; B; C) D 就是 A; while (B) { D; C; }。

while 的头号死循环陷阱 —— 忘记写更新语句：

1
while (k >= m) {
2
    if (k % 4 != 0) { printf("%d\n", k); return; }
3
    /* 忘了 k -= 7;  ->  k 永远不变，条件永远成立 -> 死循环（OJ 报 TLE）*/
4
}

规则：更新语句要放在循环体里”每条路径都会经过”的位置，不要藏进 if 里面。

情况二：更新语句不止一条（第 34 题）

1
while (sum + fact < n) {
2
    sum += fact;            /* 少这条 -> sum 不变 -> 死循环 */
3
    m++;                    /* 少这条 -> m 不变 -> 答案永远是 0 */
4
    fact *= (m + 1);        /* 少这条 -> fact 不变 -> 死循环 */
5
}

三条更新少任何一条，不是死循环就是答案错。 写完对着数一遍：是不是三条都写了？

为什么这种题不用 for：for 的第三格只装得下一个式子，三条得挤成逗号表达式很难读；而且”循环几次”事先不知道，本来就该用 while。

★「先问后加」比「先加后撤」好#

第 34 题的精髓 —— while 的条件只”问”不”改”，是试探：

1
while (sum + fact < n) {   /* 问：加进去还成立吗？ 只算，不写回任何变量 */
2
    sum += fact;           /* 答"成立"才真的加 */
3
}

对比”先加后撤”的写法（要多一句 mm-- 回退）：

1
while (1) {
2
    mm++;
3
    f *= mm;
4
    if (s + f >= n) { mm--; break; }   /* ★ 得撤销刚才那一步 */
5
    s += f;
6
}

多一步回退，就多一类可能忘写的地方。能”先问后加”就别”先加后撤”。

类型溢出速查（什么时候必须 long long）#

溢出的表现：结果变成负数，或者”条件永远成立”造成死循环。 判断口诀：题目给了范围，就把范围上限代进去，手算一下最大值。

另一个信号：题目里写”注意计算过程中的类型溢出问题” → 直接上 long long。

★★ 最阴的一种溢出：结果没超，中间过程超了（第 39 题）#

题目说”输入保证最终结果在 int 范围内”—— 这句话只保证结果，不保证过程。

第 39 题：n, m ≤ 1000000，求最大公约数和最小公倍数。

1
   最小公倍数 = n * m / gcd
2

3
   题目保证【最小公倍数】≤ int 上限 ✔
4
   但没人保证【n * m】不超 —— 它最大能到  1000000 × 1000000 = 10^12
5
   int 上限是 2147483647（约 2.1×10^9）
6
   →   n * m 最大是 int 上限的 466 倍  ●

现场实测（n = m = 1000000）：

1
   gcd = 1000000，正确答案 = 1000000   （确实在 int 范围内 ✔）
2

3
   真实的 n*m                    = 1000000000000
4
   当成 int 看                   = -727379968      ← 已经变成负数了
5

6
   写法1  n * m / gcd            = -727            ★错★
7
   写法2  n / gcd * m            = 1000000         ✔

最小的能触发的输入：n = m = 46341 —— 46341 × 46341 = 2147488281，只比 int 上限大 4634，n*m/gcd 就输出 -46340 而不是 46341。

四种写法对照：

实测：n,m = 1~2000 全部 400 万组合法输入 —— 写法2 错 0 处、写法3 错 0 处；而在 999000~1000000 区间里挑出的 1487 组合法输入，写法1 和写法4 全错。

★ 通用规律：把”危险的运算”放到最后一步。

“能先约分就先约分” —— 数学上等价的式子，计算顺序不同，安全性完全不同。

⚠️ 还有一种”半途而废”的 long long（写法4）：cast 写在最外面，等于什么都没救。要保证乘法本身发生在 long long 里。

“能不能不枚举”—— 范围一大就要先想这句#

看到 “小于 10 的 9 次方 / 10 的 12 次方” 这种规模，先问一句：真的要一个个试吗？

第 32 题的两个新套路：

• 求”满足条件的最大值” → 不要从头扫，从上界往下退：k = n/7*7; 然后 k -= 7;
• 求”某数的倍数” → 用 / 和 * 一步跳过去，不用循环：n/7*7 就是”不超过 n 的最大 7 的倍数”

能算出公式/跳着走的，就不要枚举。

★ 第一个算法：辗转相除法（第 38 题）#

这是学到的第一个”有名字的算法”。 以前是”把循环和分支拼出来”，从这里开始要问：“这题有没有一个聪明的办法？”

暴力做法为什么不行（实测循环次数）：

题目上限 10^9，判题机一秒约跑 1 亿次 → 枚举必然超时。

核心公式：gcd(m, n) = gcd(n, m % n)，反复套用到第二个数变成 0，此时第一个数就是答案。

三行骨架（★ 值得背下来）：

1
while (n != 0) {
2
    r = m % n;      /* ① 先算余数并【存起来】 */
3
    m = n;          /* ② 小的那个上位 */
4
    n = r;          /* ③ 余数接着当除数 */
5
}
6
printf("%d\n", m);  /* n 变 0 时，m 就是答案 */

⚠️ 顺序绝对不能反。 写成 m = n; n = m % n; 就错了 —— 实测 gcd(48,18) 输出 18（m 已被覆盖成 18，18 % 18 = 0，第一轮就结束）。 这和斐波那契 int t = a + b; a = b; b = t; 是同一个「滚动变量」套路：先存临时变量，再移动。

两个不用操心的地方：

• 不用特判 m < n：实测 4 6 第一轮 4 % 6 = 4，自动就变成 (6, 4) 了。
• 不会死循环：每轮 m % n 严格小于 n，第二个数一路严格变小，必然碰到 0。

为什么”一直除余数”能得到公约数（一句话版）： m % n 的意思就是”把 m 里的 n 一个个减掉，减到减不动为止”。而减去几个 n 不会改变公约数的集合 —— 实测 gcd(48,18) 四步 (48,18)→(18,12)→(12,6)→(6,0)，每一步的”公有约数”全都是 1 2 3 6，一个字没变。

更快的口诀记忆：% 就是”更相减损术的快进版”（48→30→12 要减 2 次，48 % 18 = 12 一步到位）。

为什么停在 (m, 0)：0 能被任何正整数整除，所以”m 和 0 的公约数”就是”m 的所有约数”，最大的是 m 自己 → gcd(x, 0) = x。

最坏情况是相邻斐波那契数（因为互质）。10^9 以内最大一对 gcd(701408733, 433494437) 要 42 轮。这叫 Lamé 定理：轮数不超过 5 × 位数。

两个前瞻：

• 递归版（等学函数）：int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
• 最小公倍数：m / gcd * n —— 必须先除后乘，因为 m * n 在 10^9 量级是 10^18，int 装不下
• 扩展欧几里得（以后数论会遇到）：能顺便求出 a*x + b*y = gcd(a,b) 的 x, y，用于求模逆元（RSA 加密）

第 38 题实测记录：400 万对穷举（1~2000）+ 200 万对随机大数（上限 10^9）+ 9 万对与”从大到小枚举”对照 + 42 对相邻斐波那契 + 20 万组倍数性质 → 不一致 0 处；gcc -Wall -Wextra 零警告；gcc -std=c89 -pedantic-errors 通过。

★ 变量声明一律写在 main 开头#

第 36 题第 10 行 int yu=0; 写在 scanf 语句之后 —— 这叫”声明与语句混写”，严格 C90 标准不允许：

1
gcc -std=c89 -pedantic-errors -Wall
2
  →  error: ISO C90 forbids mixed declarations and code

本地 gcc 默认用新标准，只给个警告就过去了；但很多判题机用很老的编译器（VC++ 6.0 或强制 C90 的 gcc），那里这是硬错误，直接判”编译错误”。

改法：把变量全挪到最上面 —— int n = 0, yu = 0;

同理：for (int i = 0; ...) 里的 i 也是 C99 才允许的，老判题机会报错。养成先写 int i; 放最上面的习惯。

★ 命令行坑（不是 C 的问题，但会白耽误时间）#

现象：在 PowerShell 里想把”编译 + 运行”一次搞定，写了 cmd / Linux 风格的 && 或 &：

1
所在位置 行:1 字符: 2
2
+ 2& D:\code\1.exe
3
+  ~
4
表达式或语句中包含意外的标记“&”。
5
    + FullyQualifiedErrorId : UnexpectedToken

这不是判题机的报错，是 PowerShell 在抱怨命令本身 —— C 代码一个字都没被执行。

正确写法（二选一）：

1
# 写法 A：分成两行，最省心
2
gcc -Wall -Wextra -o D:\code\1.exe D:\code\1.c
3
D:\code\1.exe
4

5
# 写法 B：用分号 ; 连成一行（PowerShell 的语句分隔符是 ;）
6
gcc -Wall -Wextra -o D:\code\1.exe D:\code\1.c ; D:\code\1.exe

想直接把输入喂进去： '12354' | D:\code\1.exe

记三句话：PowerShell 分隔语句用 ;；&& 只在 7.0 以后才有；& 是”调用一个命令”的运算符，不是分隔符。

怎么区分报错来源：带 ParserError / CategoryInfo / FullyQualifiedErrorId 字样的是 PowerShell 在说话；判题机的提示只有一行 文件名:行号: error: ...，或者”编译错误 / 答案错误 / 格式错误 / 运行超时”这类中文短语。

抓手一：四句填空法 —— 专治”看得懂但写不出来”#

“看懂”不等于”会写”。 每拿到一道输入输出题，只按顺序回答四句话，代码是被这四句话”逼”出来的，不是背出来的：

四级台阶（判断自己离”独立写出来”还有多远）：

抓手二：变量名用足拼音#

英文单字母名（w h best sum）在脑子里是纯噪声，看不出”人数""几点""最多”，于是写代码时”指错对象”。

1
   w + x              ← 没有语义差别，只是字母
2
   xiaoshi + shicha   ← 差的是一个完整单词，一眼分开

三条规则：

1. 用完整拼音，不缩写 —— renshu ✔，rs ✘
2. 一个概念一个名字 —— 分钟用 fenzhong 就不要再叫 shi
3. i / j 保留字母（下标全世界的 C 代码都这么写）

常用角色固定名：计数器 geshu/cishu｜累加器 he/zonghe｜最大值 zuiduo/zuida｜最小值 zuixiao｜标志位 biaozhi｜临时变量 linshi｜数组(桶) tong[]/shuzu[]｜长度 changdu

★ 复盘出的核心诊断（比任何语法点都重要）#

7-5 四个空全错，但四个错里没有一个是”不会 C”：

结论：短板不是语法，是”精确指称”。 方法：写代码前先列「变量角色表」（每个变量是什么、最容易跟谁混），每写一行先口头念一句”我要用哪个变量”。

★ C 的负数取模（跨时区/环形题必踩）#

1
   -3  % 24  =  -3     ← C：符号跟着【被除数】走
2
   -3  % 24  =  21     ← Python：不一样！

环形下标一律写两层：((x % 24) + 24) % 24

• 第一层 % 24 → 范围 (-24, 24)，可能为负
• + 24 → 范围 (0, 48)，一定非负
• 再 % 24 → 收回 0..23

漏掉两层的后果：实测某基地 100 人、时差 x = -20，漏写时 h-20 恒为负 → 这个基地一次都不被算进去 → 答案从 100 变 0。不崩溃、不警告，只是悄悄少算。