C语言程序设计课上有一道经典作业，题面叫“水手分叶子”。第一次看到这个题目，我以为是网上流传的“水手分椰子”换了个名字，随手就打算去搜答案。结果真正上手才发现，光是“每次多出的一片叶子”这个条件怎么翻译成代码，我就写错了好几版。

这道题表面上是编程题，骨子里却是递推关系、整除判断、枚举策略加在一起的一整套数学问题。这篇文章把我从读题、建模、写代码，到踩坑排查的完整过程整理出来。如果你也在某高校的C语言课上被类似题目卡住，或者想搞懂“猴子分桃”“水手分椰子”这类题到底怎么解，可以顺着这篇文章的思路自己动手跑一遍。核心关键词就三个：水手分叶子、C语言、背后的数学问题。

1. 问题还原：水手分叶子到底在算什么

1.1 原题描述与“椰子变叶子”的来历

题目一般这么写：有一堆叶子，5个水手和一只猴子漂流到一座荒岛上。第一天采完叶子后，第一个水手夜里醒来，把叶子分成5堆，发现总是多出1片，就把多的那片扔给猴子，然后自己拿走其中一堆。第二个水手醒来后，不知道已经有人分过，又把剩下的叶子分成5堆，发现也多出1片，于是扔给猴子，自己拿走一堆。第三、第四、第五个水手都做了同样的事。第二天早上，5个人一起把剩下的叶子分成5堆，这次刚刚好分完，一片不多一片不少。问：这堆叶子最少有多少片？

如果人数不是5，就改成N个水手，其余规则完全一样。把“椰子”换成“叶子”，大概率是老师为了让学生不能直接照搬网上的答案，或者单纯想增加一点趣味性。不管名字怎么变，数学结构都没变。这类题还有一个更古老的门派叫“猴子分桃”，几只猴子轮流分一堆桃子，每次多一个。说白了，全是同一个模型换了件马甲。

1.2 边界条件才是题目的灵魂

读题时最容易漏掉三个边界条件。

第一个：每个水手分的时候，叶子总数必须满足“模N等于1”。也就是说，一堆叶子拿去分成N堆之后，必须还剩1片，这一片归猴子。

第二个：每个水手拿走一堆之后，剩下的叶子要留给下一个人。这个“剩下”必须是一个正整数，而且还得满足下一个水手继续分的要求。

第三个：第二天早上这一次，是“刚好分成N堆”，既不能多一片也不能少一片，而且一般不再提猴子。也就是说，早上的总数必须能被N整除。

很多人把第三个条件漏掉，或者想当然地认为最后一次也是“多1片扔猴子”，结果求出来的数怎么都对不上。我一开始就是这么错的。提前把这三个边界条件用数学语言写清楚，后面写代码会顺畅很多。这就是为什么我建议拿到题目先别急着敲代码，先在草稿纸上把条件写出来。

2. 从故事到式子：这道题的数学内核

2.1 正向建模为什么让人头大

如果从初始总数x出发，第一次分完剩下的叶子数可以写成：

x1 = x - (x-1)/N - 1

第二次分完：

x2 = x1 - (x1-1)/N - 1

继续往下，第N次分完：

xN = x(N-1) - (x(N-1)-1)/N - 1

最后要求 xN 能被N整除。

式子本身不难，问题是初始x是未知的。我们只知道x是一个正整数，但根本不知道它的范围。如果非要正向解，最简单粗暴的方式就是从1开始一个一个试。人肉手算的话，试到几百、几千就得崩溃，而正确答案往往是几千甚至更大。计算机不怕重复，这就是枚举法的雏形。但枚举也有前提：你得有一个明确的搜索范围，或者接受从1开始一路试到找到为止。

这个题的正向模型还有一个麻烦：每一步都带着减1、除以N、再减1的操作，叠加起来之后，x和最终结果之间是非线性的关系，很难直接反解出一个公式来。所以正向推导适合用来做“验证”，不太适合用来“求解”。

2.2 逆推关系才是破局点

换个角度，既然正向从初始值一直算到最后很痛苦，那不如从最后一步往前倒推。

最后一步是早上平分。假设早上每个人分到s片叶子，那么早上剩下的总数就是 N*s。

再往前推一步：最后一个水手分之前，到底有多少叶子？最后一个水手分的时候，把一堆叶子分成N份，多1片给猴子，自己拿走一份，剩下的是N-1份。既然他分完之后剩下 Ns 片，而这 Ns 片对应的是 N-1 份，那么每份的数量就是：

每份 = N*s / (N-1)

这里就冒出一个关键条件：N*s必须能被N-1整除，否则这种分法在整数范围内根本不存在。

有了每份数量，最后一个水手分之前的叶子总数就是：

上一状态 = 每份 * N + 1

把这个数当作新的“当前剩余”，继续往前推倒数第二个水手分之前的数量。重复N次，得到的就是最初的叶子总数。

这就是一个标准的逆推过程：给定当前剩余，反复套用“上一状态 = 当前剩余 / (N-1) * N + 1”这个式子。核心思路是把未知的初始值换成已知的“早上每份s”，然后从1开始试s，找到第一个能让整条逆推链每一步都整除的s。

2.3 “整除”是隐藏的递推约束

逆推过程里，每一步都在做除法，除以的是N-1。所以每一步都必须满足整除条件，只要中途有一步除不尽，就说明当前s不合适，换下一个s继续试。

这个“整除”要求就是整个问题的数学开关。很多初学者写逆推时图省事，直接用了浮点数，或者用了整数除法却没检查余数，最后算出一个看起来合理实际完全错误的数。C语言的整数除法会直接把小数部分截断，不报错，所以这种错误特别隐蔽。

从同余的角度看，这个问题其实是在找满足一串同余条件的最小整数解。它和“韩信点兵”这类问题的思想有相通之处：都是在若干个整除/同余约束下找最小解。不过C语言课上不需要深入数论，只要能理解“每一步逆推都必须整除”就够了。

3. C语言实现：枚举法搞定最小解

3.1 枚举法思路与代码

枚举法的思路最接近正向思维：从1开始尝试每个整数x，模拟N个水手依次分叶子的过程，判断最后能否刚好分完。第一个满足条件的x就是最小解。

#include <stdio.h> int main() { int n = 5; // 水手人数，经典题是5 long long start = 1; // 从1片叶子开始枚举 while (1) { long long x = start; int ok = 1; // 模拟每个水手分叶子的过程 for (int i = 0; i < n; i++) { if (x % n != 1) { // 分成n堆必须多1片 ok = 0; break; } // 拿走一堆，外加猴子的一片 x = x - (x - 1) / n - 1; } // 早上最后一次：必须刚好分成n堆 if (ok && x % n == 0) { printf("最少叶子数: %lld\n", start); break; } start++; } return 0; }

这段代码的核心是这一行：

x = x - (x - 1) / n - 1;

为什么不是 x = x - x/n？因为猴子要先拿走一片，剩下的 x-1 片才参与分成n堆，每堆是 (x-1)/n 片。把猴子的一片和拿走的一堆都减去，剩下的才是留给下一个水手的量。这个式子写错的人非常多，我第一次就写成了 x - x/n - 1，结果所有答案都差了那么一点。

3.2 验证3121是怎么来的

n=5跑一遍，start从1开始，一直试到3121才第一次满足条件。完整的分配过程是这样的：

• 初始3121，分成5堆每堆624，多1片给猴子，拿走624，剩2496
• 第二次2496，分成5堆每堆499，多1片给猴子，拿走499，剩1996
• 第三次1996，分成5堆每堆399，多1片给猴子，拿走399，剩1596
• 第四次1596，分成5堆每堆319，多1片给猴子，拿走319，剩1276
• 第五次1276，分成5堆每堆255，多1片给猴子，拿走255，剩1020
• 早上1020，分成5堆每堆204，刚好分完

这个验证过程我建议你自己手动算一遍，因为算完会对递推关系有非常直观的感受。算完之后你会明白，为什么答案不是3120也不是3125，而偏偏是3121。

3.3 枚举的效率与局限性

n=5时答案只有3121，外层循环3121次，每次内层做5次操作，总共一两万次，秒出结果。但n变大之后情况就不同了。水手人数从5变成6时，答案会跳到很大的数，枚举次数可能达到几万甚至几十万，虽然程序照样能跑，但效率开始变差。

枚举法的优点是逻辑简单，顺着题意就能写，不容易出错。缺点是搜索空间大时效率低，而且完全没有利用题目本身的递推结构。这就像在一个停车场里找一辆车，枚举法从第一辆车开始挨个看，最后一定能找到，但如果停车场特别大，就显得很笨拙。

4. 进阶解法：从最后一天往前逆推

4.1 逆推法的式子梳理

设早上每人分到s片叶子，那么早上剩下的总数就是 n*s。

逆推时每一步都在做这样一件事：当前剩余是上一个水手分完之后留下的N-1份，那么上一步每份就是当前剩余除以N-1。上一步的总量就是每份乘以N，再加上给猴子的那1片。

写成递推式就是：

if (当前剩余 % (n - 1) != 0) 当前s不成立; 当前剩余 = 当前剩余 / (n - 1) * n + 1;

反复执行N次，得到的就是最开始的叶子总数。让s从1开始往上试，找到第一个能完整逆推N次的s即可。

这里有个细节值得说清楚：为什么检查的是“当前剩余 % (n-1)”，而不是“当前剩余 * n % (n-1)”？因为公式里是先除后乘，只要当前剩余能被n-1整除，乘以n之后再除以n-1也一定整除，因为n和n-1是互质的。反过来，如果当前剩余不能被n-1整除，那乘以n也不可能把它变成整除。所以只需要检查“当前剩余 % (n-1)”即可。

4.2 逆推法C语言实现

#include <stdio.h> int main() { int n = 5; long long s = 1; // 早上每人分到的叶子数，从1试起 while (1) { long long x = n * s; // 早上剩下的总数 int ok = 1; // 反推每个水手分之前的数量 for (int i = 0; i < n; i++) { if (x % (n - 1) != 0) { // 必须能整除 ok = 0; break; } x = x / (n - 1) * n + 1; // 上一状态的叶子总数 } if (ok) { printf("最少叶子数: %lld\n", x); printf("对应早上每份: %lld\n", s); break; } s++; } return 0; }

n=5时，s会从1试到204，最终ok成立，输出x=3121。可以看到，逆推法外层循环只跑了204次，而枚举法跑了3121次。虽然两种方法都能出结果，但逆推法明显更优雅，因为它枚举的对象从“初始未知数x”变成了“最后的每份s”，而s的范围比x小了一个数量级。

这也引出一个很重要的工程思维：同样一个问题的求解，改变枚举对象往往能大幅缩小搜索空间。以后碰到需要穷举的题目，可以先想想能不能换个角度，从结果往回枚举。

4.3 两种解法的对比与选型建议

如果你是在完成课程作业，我的建议是先写枚举法保底，确保理解题意，再写逆推法体会数学结构。如果是面试或竞赛里遇到同类题，优先逆推，因为n稍微一大，枚举法的劣势就非常明显。两种解法我都会写一遍，不是为了炫技，而是为了让自己真正理解这道题到底在考什么。

5. 写这类题我踩过的坑

5.1 无限循环：忘了break

枚举法里如果while(1)内部的break条件写错，程序就会死循环。最常见的错误是找到ok之后忘记break，或者把break写在了内层for里，导致外层while一直跑。我第一次跑的时候程序卡住不动，我以为是电脑问题，后来才发现是break位置放错了。

调试方法很简单：在start++前后加printf打印当前值，或者先用for循环加一个很大的上限，比如1000000，先跑通再改成while。我后来干脆在枚举法里直接写了for (long long start = 1; start < 1000000; start++)，这样就算逻辑有bug也只会跑一百万次，不会死循环。

5.2 整除判断想当然

逆推法里检查x % (n-1) == 0，这个判断必须放在除法之前。有人图省事写成：

x = x * n / (n - 1) + 1;

一旦遇到不能整除的情况，C语言会直接把小数部分截断，得到错误结果，而且完全不会报错。我在调试逆推法时，有一版输出一大堆奇怪的数，后来打印了每一步的x，才发现是整除判断被我去掉了，导致中间某一步悄悄丢掉了余数。这种错误特别隐蔽，因为大部分测试用例恰好都能整除，跑到某个s时才突然算错。

5.3 int溢出问题

n=5时3121还在int范围内，但逆推过程中间值会先膨胀。比如从早上剩余1020反推第一步，x = 1020 / 4 * 5 + 1 = 1276，还在int范围内。但如果n改成6，s稍大一点，x会快速变大，int很可能就装不下了。

经典题5个水手时没问题，一旦改成6个、7个水手，中间临时结果很可能超过int上限。我的建议是直接使用long long，printf用%lld。这个问题在C语言课上经常被忽略，因为老师的测试用例通常只有n=5，答案3121用int完全够，但如果你自己扩展去试n=6，就会踩坑。

5.4 把“早上分完”理解错

最后一个条件是“早上刚好分成n堆”，不是“早上也剩一片给猴子”。这个条件第一次写很容易错。有人模拟的时候把早上也当作模n等于1，结果求出的答案偏大；有人把早上想成“最后每人分到s片，但总数不是n*s”，导致逻辑混乱。

代码里，早上的检查是x % n == 0，其他时候的检查是x % n == 1，两种条件必须分开。我把这点单独拎出来说，是因为它确实是这道题最容易理解错的地方，没有之一。我的教训是：读题时把“白天”和“晚上”的操作分开，模拟代码里也分开判断，思路会清楚很多。

5.5 处理“多一片”时先减再除

正向模拟时，计算每堆数量要用(x - 1) / n，必须先减1再整除。如果直接写x / n，就相当于没把猴子那片先拿出来，算出来的“拿走一堆”就偏大，剩余就偏小，最终答案完全不对。

逆推时也类似的坑，公式是x = x / (n - 1) * n + 1，必须先除后乘。有人担心整数除法丢精度，先乘后除，结果中间数变大甚至溢出。在C语言里，先除后乘虽然看起来“损失精度”，但因为我们保证了整除条件，实际上完全精确。这个顺序问题我一共写错过两次，现在看到这类题都会条件反射地检查运算顺序。

6. 还可以继续往下玩：变体与扩展

6.1 水手人数动态输入

把代码里的n改成scanf("%d", &n)，程序就能求任意水手人数的解。我试过输入4、5、6，观察答案的增长速度，对这道题的“指数级膨胀”会有非常直观的感受。题目如果要求输出每一步分完还剩多少，也只需要把循环里的x值存到数组里，最后统一打印。

比如n=4时，答案不再是常见的3121，而是更小的数；n=6时，答案会明显比5个水手大好几倍。这种动态输入版本很适合用来给朋友出题，让他们猜答案，基本没人能猜中。

6.2 每次多出的叶子数不是1

如果把“每次多1片”改成“每次多k片”，递推关系就变成：

上一状态 = 当前剩余 / (n - 1) * n + k

整除判断和枚举判断同步修改即可。这个变体让题目的适用面更广，理解了它，以后碰到任何“余数版本”都不慌。我在改这个版本时，又踩了一次整除的坑，因为k的变化会影响余数的约束条件，判断条件不能直接照抄。

6.3 谈一谈数学通解

当n确定时，这类问题其实可以推出封闭形式的通项公式，本质上是解一组同余方程。经典5个水手、每次余1片的版本，最小解3121恰好可以写成5的5次方减4，但这是特定条件下的结果，其他n不一定有同样的规律。如果真想找通项，建议走“假设早晨每份为s，代入递推链解同余方程”的路线，不要盲目套公式。

C语言课上能写清楚逆推法已经足够，再往上就是数论的内容了。不过了解这个方向没有坏处，至少让我明白了这道题为什么会被放进程序设计课：它不只是考语法，更是考建模能力。数学模型建立得越清晰，代码写得就越稳。

最后分享一个我自己的体会。这道题我前前后后写了三版，第一版逻辑全对但类型用了int，n=6直接溢出；第二版逆推方向搞反，出来的数大得离谱；第三版才把整除条件彻底想明白。回头再看，“水手分叶子”之所以经典，不是因为代码有多难，而是它把枚举、递推、整除判断这三样基本功藏在了一个有意思的故事里。希望你在自己学校的C语言课上遇到它时，别急着搜答案，先花十分钟把数学式子列出来，代码会好写很多。