做 PAT 甲级的朋友应该都有这种感觉：有些题看着简单，提交之后却让你一脸懵。PAT-A-1024 就是典型。题目名字叫 Palindromic Number，表面上是回文数判断，但真正拦住大多数人的，是藏在数据范围背后的“大数相加”。我第一次做这题时，老老实实写了翻转、判断回文、long long 相加，样例一遍过，点提交直接挂掉一半测试点。原因很简单——N 最大 10^10，K 最大 100，每翻转加一次，位数就可能涨一位，long long 根本扛不住。这篇就把这题的完整思路、可提交的 C++ 代码，以及我在高精度加法上踩过的坑一并说清楚，适合刚上手 PAT 甲级、或者对字符串模拟大数还不熟悉的同学。
1. 题面背后真正想考的，不是回文而是大数
1.1 三个输入要素导致的数据膨胀
这道题输入只有两个值：一个初始数字 N 和一个最大步数 K，其中 N 不超过 10^10，K 不超过 100。很多人看到 N <= 10^10，觉得 long long 能装下，就直接写整型加法了。关键是题目还有后半句：如果做了 K 步之后还不是回文，你要输出第 K 步的结果。换句话说，你最多要模拟 100 次翻转相加。
一次翻转相加最多让位数增加多少？两个 n 位数相加，结果要么还是 n 位，要么因为最高位进位变成 n+1 位，不存在一次增加两位的可能。N 初始最多是 11 位（10000000000 刚好是 11 位），每步最多涨 1 位，100 步之后最多是 111 位。你再看 long long 的范围，最大也就大约 9.22e18，十进制下 19 位。19 位对 111 位，中间差着两个数量级。
这就是这道题的第一层陷阱：它明面上是回文数问题，实际考的是你能不能预先估算出中间结果的数据范围。考场上不少人样例过了，提交之后答案错误，大概率就是死在用整型存中间结果这条路子上。
1.2 回文判断只是基本功，大数相加才是分水岭
回文数本身不难，任何一个学过字符串反转的人都能写。但 PAT 甲级的题目往往不会只考一个单一知识点，它喜欢把基础操作组合起来：这题把“判断回文”和“高精度加法”叠在一起，并且用数据范围制造了一个看似不起眼的障碍。
从命题角度看，回文判断是地表最强的“伪装”：它让题目看起来人畜无害，实际上重点考察的是考生对数据范围的敏感度。如果你做过足够多的 PAT 真题，会发现这种“读题时觉得简单，做起来发现要写高精度”的套路出现过不止一次。所以别被 Palindromic Number 这个名字骗了，本题的正确打开方式，是把它当成“高精度加法 + 回文判断”的组合题来准备。
2. 翻转相加的操作本质和那个不一定成立的猜想
2.1 回文定义与翻转相加的操作逻辑
什么是回文数？正着读和反着读一样。那么判断一个数字是不是回文，最直接的做法就是把它反转，然后比较两个字符串是否相等。而题目要求的操作“将 N 和它的反转相加”，本质上就是顺着回文的定义去反向逼近：如果一个数不是回文，那就让它的后半部分和前半部分通过加法互相“妥协”。
举个例子：67 反转是 76，67 + 76 = 143。143 反转是 341，143 + 341 = 484。484 正着读反着读一样，到此停止。整个过程的每一步，都是在强行让数字的左边和右边互相靠拢。这种操作逻辑很直观，但有一个细节容易理解偏：每一步加的，是“当前数字自身的反转”，而不是“某一步算出来的结果的反转”。听起来是废话，但我见过有人把中间结果搞混，循环里反复加同一个值，导致步数对但数字错。
2.2 一个没人能证但大家都默认的前提
你可能想过一个问题：为什么反复翻转相加，最后就一定会变成回文？实际上这个猜想并没有对所有整数被证明。数学上有个著名的“利克瑞尔数”概念，说的就是那些不管翻转相加多少次都不太容易变成回文的数，典型代表是 196。很多数经过几十步就会落入回文，但 196 经过极多步仍未出现回文，至今也没人严格证明它永远不会。
但做题不需要纠结这个。题目给定 K <= 100，只要求你在 100 步内找到答案，找不到就输出第 100 步的结果和 100。所以算法层面唯一的任务就是老老实实模拟，根本不需要数学证明。知道这层背景主要是为了防止你被一个更蠢的念头带偏：担心“万一死循环怎么办”。不会死循环，因为步数上限就是 100，模拟完直接输出即可。
2.3 每次迭代至少要判断一次当前数字
另一个容易模糊的点是判断时机。正确流程是：先看当前数是不是回文，如果是，直接输出；如果不是，才翻转相加，步数加一。每一步都是先判断后相加。如果你用 do-while 把“判断”放到“相加”后面，那么一个初始就是回文的数字（比如 121）会被硬加一步再输出，步数直接错掉。这个判断顺序后面会在代码里体现，这里先提个醒。
3. 用 String 模拟高精度加法：实现与选型思路
3.1 为什么不用 long long，也不建议用数组
原因前面已经算过：100 步后位数可能到 111 位，远超任何整型。模拟大数相加常用两种容器：数组和字符串。数组的好处是可以手动控制每一位，适合做更复杂的四则运算；但本题只做加法和反转，字符串有明显优势——反转可以调 reverse，输出直接 cout，长度不用预先分配，代码量和心智负担都小很多。
字符串在高精度题里是“天然容器”，因为数字本质上就是一串字符，每一位的字符减去 '0' 就是对应的整数。存储方向也值得统一：让字符串永远保持“高位在前”的顺序，也就是跟我们平时写数字的顺序一致。这样最后输出的时候不用额外处理，看代码的人也容易理解。
3.2 加法函数的完整实现与进位处理
写字符串加法，最容易翻车的地方是遍历方向。两个数字都是高位在前，所以要相加必须从最后一位（最低位）开始往前进位。如果写反了，从第一位开始算，进位方向就全乱了。
一个通用的大数相加函数可以这样写：
string addStrings(const string& a, const string& b) { string res; int carry = 0; int i = (int)a.size() - 1; int j = (int)b.size() - 1; while (i >= 0 || j >= 0 || carry) { int sum = carry; if (i >= 0) sum += a[i--] - '0'; if (j >= 0) sum += b[j--] - '0'; res.push_back(char('0' + sum % 10)); carry = sum / 10; } reverse(res.begin(), res.end()); return res; }注意循环条件里的carry：当两个字符串都遍历完但还有进位时，必须再进一位。比如 999 + 1，原长度只有 3 位，但结果是 1000，多出来的那一位就是在循环结束后由 carry 产生的。res.push_back每次把当前位的数字追加到末尾，得到的是低位在前的临时结果，所以最后要 reverse 一次恢复正常顺序。
有了这个函数，本地的翻转相加就非常简单：
string addWithReverse(const string& s) { string t = s; reverse(t.begin(), t.end()); return addStrings(s, t); }3.3 Java 和 Python 选手可以怎么“偷懒”
如果你用 Java 提交，可以直接用BigInteger，翻转可以用StringBuilder.reverse()，省掉手写高精度。如果你用 Python，那就更简单了，内置大整数直接 int 相加不会有任何溢出问题。这里不展开代码，因为 PAT 甲级的主流还是 C/C++，而且很多人刷 PAT 的目的就是为了练习数据结构和算法，建议还是自己把字符串加法写一遍，毕竟大数相加是基础中的基础，后面很多真题都会用到。
4. 判断回文的两种写法，性能和正确性都别忽略
4.1 反转后比较：直观但有一处隐患
判断一个字符串是不是回文，最容易想到的方法就是把它反转，看和原串是否相同。C++ 里可以这样写：
bool isPalindromic1(const string& s) { string t = s; reverse(t.begin(), t.end()); return s == t; }这里唯一需要注意的是：reverse是原地反转，如果你直接reverse(s.begin(), s.end())再比较，那 s 已经被改掉了，后面再用就全乱了。所以必须先把 s 拷贝一份到 t。这一步很多人踩坑，尤其是一个函数里既要判断回文又要用原串去做加法时，反转覆盖原串会让你整个逻辑陷入混乱。
4.2 双指针：空间更小，逻辑更清楚
第二种办法是双指针，从两端往中间扫：
bool isPalindromic(const string& s) { int i = 0; int j = (int)s.size() - 1; while (i < j) { if (s[i] != s[j]) return false; ++i; --j; } return true; }两种方法在这个题里时间复杂度都是 O(位数)，差别几乎可以忽略，因为位数最多也就一百多。我个人更推荐双指针，原因是它不需要额外分配字符串空间，也不会产生“拷贝还是原地反转”的歧义。代码同样短，而且一眼就能看出比较逻辑，非常契合考场这种追求“少犯错”的环境。
两种方案的对比如下：
| 方案 | 空间复杂度 | 主要风险 |
|---|---|---|
| 反转后比较 | O(n) | 忘记用副本，反转覆盖原串 |
| 双指针 | O(1) | 无特别风险，注意 i < j 即可 |
5. 完整代码与样例推演：从67到484的每一步
5.1 可提交的 C++ 代码
把上面的判断和加法组合起来，主循环用“先判断、后相加、再计数”的节奏，完整代码长这样：
#include <iostream> #include <string> #include <algorithm> using namespace std; bool isPalindromic(const string& s) { int i = 0; int j = (int)s.size() - 1; while (i < j) { if (s[i] != s[j]) return false; ++i; --j; } return true; } string addStrings(const string& a, const string& b) { string res; int carry = 0; int i = (int)a.size() - 1; int j = (int)b.size() - 1; while (i >= 0 || j >= 0 || carry) { int sum = carry; if (i >= 0) sum += a[i--] - '0'; if (j >= 0) sum += b[j--] - '0'; res.push_back(char('0' + sum % 10)); carry = sum / 10; } reverse(res.begin(), res.end()); return res; } string addWithReverse(const string& s) { string t = s; reverse(t.begin(), t.end()); return addStrings(s, t); } int main() { string n; int k; cin >> n >> k; int step = 0; while (step < k) { if (isPalindromic(n)) { break; } n = addWithReverse(n); ++step; } cout << n << '\n' << step << '\n'; return 0; }这个主循环为什么要写成while (step < k)而不是for (int step = 0; step < k; ++step)？两者其实都能用，但 while 版本更容易保证“初始就是回文”时 step 不额外增加。每次进入循环先判断当前数，是回文就 break，不是才相加并计数。就算不用 break，写成while (step < k && !isPalindromic(n))也是同样效果，逻辑更紧凑。
5.2 手动推演样例：67 和 3
拿样例67 3走一遍：
- 第 0 步：当前数是 67，判断回文，67 与 76 不同，不是回文。执行相加：67 + 76 = 143，step 变成 1。
- 第 1 步：当前数是 143，判断回文，143 与 341 不同，不是回文。执行相加：143 + 341 = 484，step 变成 2。
- 第 2 步：当前数是 484，判断回文，相等，是回文。break 退出。
- 输出：484 和 2。
再看一个边界场景：输入121 3。初始就满足回文，循环第一次进去直接 break，step 保持 0，输出121 0。这个测试点专门用来卡住那些把“判断”放到“相加之后”的写法。
5.3 用一个更长数字验证高精度确实必要
假设输入99999999999 100。这是一个 11 位数，反转相加第一次就变成两个 11 位数的加法。随着迭代继续，位数会慢慢增长，用 long long 的话可能在十几步后就开始溢出。你可以自己试一下，把99999999999手动迭代几步，很快就超过 19 位，long long 当场爆炸。字符串版本则完全不受影响，它一次处理一个字符，位数多少只影响循环次数，不影响正确性。
6. 这类题最容易踩的坑，以及考试时的判断顺序
6.1 四个经典错误，每一个我都见过
第一个错误是用整型存中间结果。样例太小，看不出问题，提交之后答案错误或者运行时错误。解决办法就是题目读完直接看数据范围，N <= 10^10 加上 K <= 100，立刻转向字符串。
第二个错误是字符串相加时没有对齐。假设 s 是143，t 是反转后的341，你循环里如果用s[i]加t[i]，那s[0]是百位，t[0]是个位，完全错位。正确做法是让两个指针分别从各自字符串的末尾往前走，也就是我用addStrings里的双指针遍历。这个坑特别隐蔽，因为答案有时候看起来还挺像回事。
第三个错误是把判断回文放到相加之后。用 do-while 实现时，初始回文数也会被强行加一步，导致步数多 1。刚才用 121 验证过，这是送分题变送命题的典型。
第四个错误是忘记处理最后的进位。999 加 1 等于 1000，如果你在循环结束后不看 carry，结果就只剩“000”，反转后是“000”，输出的数直接少了一位。字符串加法里最后一位进位是最容易丢的，记得在循环条件里加上|| carry。
6.2 拿到题目先问自己一句：这个数会多大
我现在做字符串模拟的题，养成一个习惯：读题先圈数据范围，然后心算一遍中间结果的上限。具体到这题，就是“N 最多 11 位，K 最多 100 步，每步最多加 1 位，最多 111 位，long long 只有 19 位，所以必须用字符串”。这个计算不需要纸笔，几秒就能完成，但能帮你避开最致命的实现方向错误。
如果数字中间结果可能在 20 位以内，可以考虑 long long；超过 20 位，直接上高精度模板。多问这一句，能让你在考场上少走很多弯路。
6.3 把 addStrings 当模板函数记下来
像addStrings这种通用数字字符串加法，在 PAT 里出现频率很高，不只是这一题。建议你把这段代码单独存成一个模板，遇到“两个大数相加”“大数加小整数”“高精度乘法”时都可以从它扩展。字符串加法的核心框架就是双指针逆序遍历加进位处理，这个框架一旦熟练，很多看似复杂的大数题只是换了一层皮。
我自己最初也写错过一版，把判断和加法顺序搞反，导致 121 这种本来就是回文的数硬生生算成 1 步。后来养成的习惯是先写isPalindromic，再写addStrings，主循环里用先判断再相加的结构，这道题就很稳了。PAT-A-1024 难度不算高，但它把高精度、字符串处理和逻辑顺序三个点揉在一起，非常适合用来打磨基础。后面遇到类似题目时，你也可以试试用这套流程：先估范围，再定容器，最后用最小逻辑写模拟，至少能少踩一半的坑。
