中心对称数这个题目，我第一次看到的时候以为是在考字符串回文，读完题才发现完全不是一回事。它考的是数字在特定字体下旋转180度之后是否还是原来的数，本质上是字符映射加构造逻辑的组合题。这类题在丙组T2的位置出现，难度控制得比较克制，但坑点密度不低，尤其是前导零和中间位处理这两块，每年都有不少选手在这里翻车。我后来带过几批刚学C++的学生做这道题，发现大家卡住的地方高度集中，所以干脆把这道题从头到尾拆一遍，把思路、实现、调试和避坑都写清楚。

这篇文章适合正在准备算法竞赛初阶组别的同学，也适合想拿一道具体题目来练手字符串处理和构造思维的开发者。我会从题目本质讲起，把为什么这样设计、每一步怎么想、代码怎么写、错了怎么查，全部摊开来说。读完你应该能独立复现这道题，并且能把类似的构造类题目迁移过去。

1. 题目本质与核心思路拆解

1.1 中心对称数到底在考什么

先把概念说清楚。中心对称数指的是这样一个数字：把它写出来，然后整体旋转180度，得到的还是同一个数。注意这里的关键词是“旋转”而不是“翻转”或“镜像”。旋转180度意味着每一位数字都要变成另一个特定的数字，同时整个数字的顺序要反过来。

哪些数字旋转180度之后还是合法数字？只有五个：0变0，1变1，2变2，5变5，8变8。另外6和9互相转换，6旋转后变9，9旋转后变6。其余数字3、4、7旋转之后就不是合法数字了，所以任何包含3、4、7的数都不可能是中心对称数。

这个映射关系是整道题的地基。你可以把它记成一张表：

题目通常的问法是：给定一个长度n，问有多少个长度为n的中心对称数，或者按某种顺序输出这些数。丙组T2的常见设定是统计个数或者构造输出，具体形式可能因场次略有差异，但核心逻辑一致。

为什么这个题放在T2？因为它不需要复杂的数据结构，也不需要动态规划，纯粹是数学观察加循环构造。但它对细节的要求很高，稍不注意就会在边界上出错。这正是T2这个位置的典型特征：思路不难，但实现要稳。

1.2 为什么用构造法而不是枚举法

最直接的想法是枚举所有n位数，逐个判断是不是中心对称数。n位数从10^(n-1)到10^n-1，n稍微大一点这个范围就爆炸了。比如n=10，要枚举九十亿个数，显然不现实。所以必须换思路。

正确的做法是构造：一个中心对称数由它的前半部分完全决定。因为旋转180度之后顺序反转，所以后半部分其实是前半部分旋转后的逆序。换句话说，只要确定了前一半的数字，后一半就唯一确定了。

这里要分奇偶讨论。设长度为n：

• 如果n是偶数，前n/2位可以自由选择（每一位从允许的集合里选），后n/2位由前n/2位旋转并逆序得到。
• 如果n是奇数，中间那一位必须是自己旋转后还是自己的数字，也就是只能从0、1、2、5、8里选（6和9不行，因为6旋转后是9，不是自己）。前(n-1)/2位自由选择，后(n-1)/2位由前面旋转逆序得到。

这个构造思路把问题从“枚举所有数”降到了“枚举一半的数”，复杂度从10^n降到5^(n/2)左右，完全可控。

1.3 前导零这个坑为什么必须单独处理

构造的时候有一个隐蔽的陷阱：第一位不能是0。因为如果第一位是0，那这个“n位数”实际上不足n位，不符合题目对长度的要求。

但这里有个微妙之处。对于n=1的情况，数字0本身是合法的中心对称数，它就是一个一位数。所以n=1时，0要算进去。而n>1时，第一位不能是0。

很多人的第一版代码会忘记这个区分，导致n=1时漏掉0，或者n>1时多算了以0开头的构造。这个点我在带学生的时候见过太多次，几乎每三个人里就有一个在这里出错。

处理方式很直接：如果n==1，特殊处理，答案里包含0、1、2、5、8这五个（注意6和9单独一位不行，因为旋转后变成对方，不是自己）。如果n>1，第一位从1、2、5、6、8、9里选（排除0），其余自由位从0、1、2、5、6、8、9里选。

注意：中间位（n为奇数时）的候选集合是0、1、2、5、8，不含6和9。这个集合和自由位的集合不一样，写代码时要用两个不同的候选数组，别图省事共用一个。

2. 核心细节解析与实现要点

2.1 映射表的两种组织方式

映射关系在代码里有两种常见组织方式，各有适用场景。

第一种是用数组做直接映射，下标是原数字，值是旋转后的数字：

int mp[10] = {0, 1, 2, -1, -1, 5, 9, -1, 8, 6};

这里-1表示该数字旋转后不合法。这种写法查询是O(1)，很直接。但要注意初始化时把3、4、7对应的位置设成-1，别漏了。

第二种是用两个候选数组，一个给自由位用，一个给中间位用：

int free_digits[7] = {0, 1, 2, 5, 6, 8, 9}; int mid_digits[5] = {0, 1, 2, 5, 8};

这种写法在构造时更顺手，因为直接遍历候选集合就行，不用每次判断是否合法。我个人的习惯是两种都用：候选数组负责枚举，映射数组负责生成后半部分。

为什么后半部分要用映射而不是再枚举一遍？因为后半部分是前半部分唯一确定的，枚举它没有意义，只会增加复杂度。用映射表逐位转换再逆序，是最高效的做法。

2.2 奇偶分支的统一处理技巧

奇偶分支如果写两套代码，容易重复且容易出错。有一种统一处理的方式：把构造过程看成“填n个位置”，对于位置i（从0开始），如果i < n/2，它是自由位；如果i == n/2且n为奇数，它是中间位；如果i > n/2，它由对称位置决定。

但更简洁的做法是先构造前半部分（长度ceil(n/2)），然后根据奇偶决定后半部分怎么补。我倾向于这种：

1. 先确定前半部分的长度half = (n+1)/2。
2. 枚举前半部分的所有可能（注意第一位非零，中间位受限）。
3. 对每个前半部分，生成完整的数：前半部分 + 后半部分，其中后半部分是前半部分的前n/2位旋转逆序。

这里有个细节：当前半部分包含中间位时，生成后半部分要跳过中间位。也就是说，取前半部分的前n/2个字符（即去掉可能的中间位），逐位映射后逆序拼接。

用字符串来处理会比用整数方便很多，因为n可能比较大，整数会溢出。丙组T2的n一般不会太大，但用字符串是更稳妥的选择，也更容易处理前导零的判断。

2.3 用字符串构造的完整流程

我习惯用字符串来拼，逻辑清晰且不怕溢出。流程如下：

第一步，确定half = (n+1)/2，这是前半部分的长度。

第二步，递归或迭代枚举前半部分的每一位。第一位（下标0）的候选是{1,2,5,6,8,9}（n>1时），其余位置的候选是{0,1,2,5,6,8,9}。如果n为奇数，下标half-1这一位是中间位，候选是{0,1,2,5,8}。

第三步，前半部分确定后，取它的前n/2个字符（即去掉中间位如果存在），逐位用映射表转换，然后逆序，拼到前半部分后面，得到完整的中心对称数。

第四步，按题目要求统计或输出。

这个流程的关键在于第三步的“取前n/2个字符”。当n为偶数时，half = n/2，前n/2个字符就是整个前半部分；当n为奇数时，half = (n+1)/2，前n/2个字符正好排除了最后一位中间位。这个统一处理很优雅，避免了两套分支。

2.4 候选集合的边界确认

写代码之前，把每个位置的候选集合列清楚，能省掉大量调试时间。

这张表建议直接贴在草稿纸上，写代码时对着看。我见过有人把中间位的候选写成全部七个，结果6和9出现在中间，构造出来的数旋转后中间位变了，整个数就不对称了。

提示：n=1是唯一的特殊情况，因为此时首位同时也是中间位，但0是允许的。如果代码里用“首位非零”一刀切，n=1就会漏掉0。建议在函数入口单独判断n==1直接返回结果。

3. 完整实现与关键环节演示

3.1 递归枚举前半部分的代码实现

下面是我常用的递归写法，用字符串累积前半部分，到达长度后生成完整数。

#include <bits/stdc++.h> using namespace std; int mp[10] = {0, 1, 2, -1, -1, 5, 9, -1, 8, 6}; int free_digits[7] = {0, 1, 2, 5, 6, 8, 9}; int mid_digits[5] = {0, 1, 2, 5, 8}; int first_digits[6] = {1, 2, 5, 6, 8, 9}; int n; vector<string> results; void build(string &half, int pos, int half_len) { if (pos == half_len) { // 生成完整数 string full = half; int back_len = n / 2; for (int i = back_len - 1; i >= 0; i--) { full += char('0' + mp[half[i] - '0']); } results.push_back(full); return; } if (pos == 0) { // 首位 for (int i = 0; i < 6; i++) { half += char('0' + first_digits[i]); build(half, pos + 1, half_len); half.pop_back(); } } else if (n % 2 == 1 && pos == half_len - 1) { // 中间位 for (int i = 0; i < 5; i++) { half += char('0' + mid_digits[i]); build(half, pos + 1, half_len); half.pop_back(); } } else { // 普通自由位 for (int i = 0; i < 7; i++) { half += char('0' + free_digits[i]); build(half, pos + 1, half_len); half.pop_back(); } } } int main() { cin >> n; if (n == 1) { // 一位数特殊处理 cout << 5 << endl; cout << "0 1 2 5 8" << endl; return 0; } int half_len = (n + 1) / 2; string half = ""; build(half, 0, half_len); cout << results.size() << endl; for (auto &s : results) cout << s << " "; cout << endl; return 0; }

这段代码有几个地方值得说明。

第一，build函数里判断中间位的条件是n % 2 == 1 && pos == half_len - 1。注意这个判断要放在首位判断之后，因为当n=1时首位和中间位重合，但我们已经单独处理了n=1，所以这里不会冲突。

第二，生成后半部分时，循环从back_len - 1开始递减到0，这就是逆序。half[i]取的是前半部分的前back_len个字符，正好排除了中间位。

第三，用char('0' + mp[...])来转换，因为mp里存的是整数，要转成字符拼进字符串。

3.2 迭代写法与递归写法的取舍

递归写法直观，但如果你对递归不熟，迭代写法也可以。迭代的核心是用一个数组记录每一位当前选到候选集合的第几个，类似进制计数的进位逻辑。

vector<int> idx(half_len, 0); while (true) { // 根据idx构造half string half = ""; for (int i = 0; i < half_len; i++) { if (i == 0) half += char('0' + first_digits[idx[i]]); else if (n % 2 == 1 && i == half_len - 1) half += char('0' + mid_digits[idx[i]]); else half += char('0' + free_digits[idx[i]]); } // 生成完整数并处理 // ... // 进位 int p = half_len - 1; while (p >= 0) { int limit = (p == 0) ? 6 : ((n % 2 == 1 && p == half_len - 1) ? 5 : 7); idx[p]++; if (idx[p] < limit) break; idx[p] = 0; p--; } if (p < 0) break; }

迭代写法的好处是不用担心递归深度，坏处是进位逻辑容易写错，尤其是limit的判断要跟位置类型对应。我一般推荐递归，因为可读性更好，调试时也更容易定位问题。

3.3 手工推演n=2和n=3验证逻辑

拿n=2手动跑一遍。half_len = (2+1)/2 = 1。首位候选是1,2,5,6,8,9。对每个首位，back_len = 1，取half[0]映射后拼上。

• 首位1：映射1->1，得到11。
• 首位2：映射2->2，得到22。
• 首位5：映射5->5，得到55。
• 首位6：映射6->9，得到69。
• 首位8：映射8->8，得到88。
• 首位9：映射9->6，得到96。

所以n=2的结果是11,22,55,69,88,96，共6个。验证一下：11旋转还是11，69旋转是69（6变9，9变6，顺序反转后还是69），都对。

再跑n=3。half_len = 2。首位候选6个，第二位是中间位候选5个。对每个组合，back_len = 1，取half[0]映射拼上。

比如首位1，中间0：half="10"，back取half[0]='1'映射为1，得到101。旋转180度：1变1，0变0，1变1，顺序反转还是101，正确。

首位6，中间0：half="60"，back取'6'映射为9，得到609。旋转：6变9，0变0，9变6，反转后是609，正确。

首位6，中间8：half="68"，back取'6'映射为9，得到689。旋转：6变9，8变8，9变6，反转后是689，正确。

这里能看出为什么中间位不能是6或9。如果中间位是6，half="16"，back取'1'映射为1，得到161。旋转：1变1，6变9，1变1，反转后是191，不等于161，所以不合法。代码里中间位候选排除6和9，正好避免了这个错误。

3.4 输出格式的注意事项

不同场次的题目对输出格式要求可能不同，有的是输出个数，有的是按从小到大输出所有数，有的是输出第k个。写代码前一定要把输出要求读清楚。

如果是按从小到大输出，要注意构造的顺序。上面的递归写法，首位按1,2,5,6,8,9的顺序枚举，中间位和自由位按0,1,2,5,6,8,9的顺序枚举，生成的数天然是递增的吗？不一定。因为后半部分是映射逆序得到的，映射会打乱大小关系。比如n=2时，首位6得到69，首位8得到88，首位9得到96，这个顺序是递增的。但首位5得到55，首位6得到69，也是递增的。实际上由于首位是递增枚举的，而首位决定了整个数的主要大小，所以整体是递增的。但严格来说，如果题目要求排序输出，保险起见还是收集完再排一次序。

提示：如果n比较大，结果数量可能很多，输出时用printf或者关闭同步的cout，避免超时。丙组T2一般n不会太大，但养成习惯没坏处。

4. 常见错误与排查实录

4.1 前导零导致的漏解与多解

这是最高频的错误，没有之一。表现有两种：n=1时答案少了0，或者n>1时答案里出现了以0开头的数。

n=1漏0的原因是把“首位非零”的规则无差别应用了。修复方法是在主函数入口单独判断n==1，直接输出0,1,2,5,8。

n>1多算0开头的原因是在首位枚举时把0也放进去了。修复方法是首位用单独的候选数组first_digits，不含0。

还有一种隐蔽的情况：n=1时如果走通用逻辑，half_len=1，首位候选是first_digits（不含0），中间位判断又因为pos==half_len-1成立而走mid_digits分支，两个分支冲突，结果不可预期。所以n=1必须单独处理，不要试图用统一逻辑覆盖。

4.2 中间位候选集合写错

中间位只能是0,1,2,5,8。如果误用了自由位的七个候选，6和9会混进去，导致构造出的数旋转后中间位变化，不再是中心对称数。

排查方法：手工构造一个中间位为6的数，比如n=3时的161，旋转后是191，验证不相等。然后在代码里打印中间位的候选，确认只有五个。

这个错误在递归写法里表现为mid_digits数组长度写成7，或者在判断中间位时用了free_digits。检查时重点看这两个地方。

4.3 后半部分逆序方向搞反

生成后半部分时，正确的做法是把前半部分的前back_len位逐位映射，然后逆序拼接。如果忘记逆序，直接顺序拼接，得到的数旋转后不相等。

举个例子，n=2，首位6。正确做法：映射6->9，逆序（只有一个字符，逆序不变），得到69。如果顺序拼接也是69，看不出问题。但n=4时，前半部分"16"，back_len=2，取"16"映射得到"19"，逆序得到"91"，完整数是1691。旋转180度：1变1，6变9，9变6，1变1，反转后是1691，正确。如果忘记逆序，拼成"19"，得到1619，旋转后是9161，错误。

排查方法：拿n=4手工推几个，对比逆序和不逆序的结果。或者直接在代码里打印后半部分的构造过程。

4.4 整数溢出与字符串选择

如果n比较大，比如n=15，结果可能超出int甚至long long的范围。用整数存储会溢出，导致答案错误。用字符串存储就没有这个问题。

丙组T2的n一般不超过10，int够用，但用字符串是更通用的做法。而且字符串处理前导零和逆序都更方便，所以我建议一开始就用字符串。

如果题目只要求输出个数而不要求输出具体数，那更简单，直接用数学公式算：n=1时5个；n>1时，首位6种选择，其余自由位7种，中间位（如果有）5种。个数 = 6 * 7^(half_len - 1 - (n%2)) * (n%2 ? 5 : 1)。但这个公式容易记错，还是构造法更稳。

4.5 常见问题速查表

4.6 调试时的一个实用技巧

构造类题目调试时，最有效的方法是写一个暴力验证函数：对构造出的每个数，真的做一次旋转180度，看是否等于自身。这个函数不需要高效，只需要正确。

bool check(string s) { string t = s; reverse(t.begin(), t.end()); for (char &c : t) { if (mp[c - '0'] == -1) return false; c = char('0' + mp[c - '0']); } return t == s; }

注意这里的顺序：先反转，再逐位映射。因为旋转180度等价于先逆序再逐位变换。用这个函数验证构造结果，能快速定位是构造逻辑错了还是映射表错了。

我一般会在小n（n<=4）时把构造结果全部过一遍check，确认无误后再跑大n。这个习惯帮我省了很多时间。

5. 从这道题迁移出去的构造思维

5.1 构造法的通用套路

中心对称数这道题的核心是“部分决定整体”。前半部分定了，后半部分就定了。这种思路在很多构造类题目里都能用。

比如回文数构造，前半部分定了后半部分就是逆序。比如某些对称字符串构造，也是类似的逻辑。识别这类题的关键是找到“自由度”在哪里：哪些位置可以自由选，哪些位置被约束决定。自由度确定了，枚举范围就确定了。

我在做题时的习惯是先数自由度。中心对称数n位，自由度是ceil(n/2)位（首位和中间位有额外约束），所以枚举量是5^(n/2)级别。这个估算能帮你快速判断构造法是否可行。

5.2 映射与逆序的组合模式

“先逆序再映射”这个模式值得单独记一下。旋转180度在数学上就是先关于中心翻转（逆序），再逐位变换。这个分解让实现变得清晰：逆序用reverse，变换用映射表，两步分开做，不容易错。

类似的组合模式还有“先映射再逆序”，对于中心对称数来说两者等价，因为映射是逐位的，和逆序可交换。但对于其他变换，顺序可能有影响，写的时候要确认清楚。

5.3 边界特殊值的处理原则

n=1是这道题的特殊值，必须单独处理。这类“最小规模特殊”的情况在竞赛题里很常见。处理原则是：如果通用逻辑在最小规模上会出错，就在入口处拦截，单独返回。

判断是否需要特殊处理的信号：最小规模时，某些约束的含义发生了变化。比如n=1时首位和中间位重合，首位非零和中间位受限两个规则冲突。这种冲突就是需要特殊处理的标志。

我在写代码时的习惯是先把n=1、n=2这些最小情况手工推一遍，确认通用逻辑是否覆盖。如果不覆盖，就在最前面加分支。这个习惯能避免很多边界错误。

5.4 字符串与数值的取舍经验

涉及前导零、逆序、逐位操作的题目，优先用字符串。涉及算术运算、比较大小的，用数值。中心对称数这道题两者都涉及，但前导零和逆序是主要操作，所以字符串更合适。

用字符串的一个额外好处是输出方便，直接拼接就行，不用处理数值转字符串的格式问题。缺点是字符串比较大小需要额外注意（按字典序比较和按数值比较不同），但这道题如果要求排序输出，可以用stoi转回来或者自定义比较。

我个人的经验是：只要题目里出现“位”“旋转”“反转”“前导零”这些词，直接用字符串，别犹豫。数值类型在这些场景下只会添乱。

5.5 复杂度估算的实用方法

构造法的复杂度估算很简单：数一数自由位的个数，每个自由位有几种选择，乘起来就是枚举量。

中心对称数n位，自由位是ceil(n/2)个，每个自由位最多7种选择，所以枚举量上界是7^ceil(n/2)。实际因为首位和中间位的约束，会小一些。n=10时，7^5约一万六，完全可控。n=20时，7^10约2.8亿，就有点大了，但丙组T2不会出这么大的n。

估算完枚举量，再估算每个枚举结果的处理时间（生成完整数、输出等），乘起来就是总时间。如果超过10^7到10^8这个量级，就要考虑优化或者换思路。这道题在丙组的n范围内，构造法绰绰有余。

6. 写在最后的一点个人体会

这道题我前前后后讲过很多遍，每次都有学生问“为什么中间位不能是6”。我的回答永远是：你拿张纸写个161，然后真的把它转180度看看。很多人转完发现是191，就再也不会忘了。算法题里很多规则，死记硬背不如动手推一遍，推一次的印象比看十遍题解都深。

另一个体会是关于调试。构造类题目出错时，别急着改代码，先手工推小规模。n=1、n=2、n=3推一遍，把正确结果列出来，再跟程序输出对比。差异出现的位置，往往就是bug所在。这个方法看起来笨，但比盯着代码看有效得多。

最后说个细节。这道题如果用递归写，注意递归深度是ceil(n/2)，n在丙组范围内不会超过递归限制，可以放心用。但如果哪天遇到n很大的变种题，记得换成迭代或者显式栈。习惯性地考虑一下递归深度，是个好习惯。