LeetCode 1033 详解：移动石子问题的数学推导与分类讨论

这个题我第一次看到的时候，心里想的是“3颗石头挪一挪，能出什么花来”。结果标题挂着“耗时100”三个字，反倒把我好奇心勾起来了：一道 Easy 难度的题，真的能磨人 100 分钟？等我自己在草稿纸上把各种情况捋完，才意识到这题一点都不“白给”。它考的不是你会不会模拟移动过程，而是你愿不愿意把边界情况想全，能不能把人人都能凭感觉说出来的“最小次数”和“最大次数”讲出严格的数学依据。

这篇文章我打算从题意理解、数学推导、多语言实现到踩坑复盘，完整过一遍 LeetCode 1033。如果你刚刷题不久，这篇文章能帮你建立“分类讨论型题目”的解题框架；如果你已经 AC 了，也可以看看我的边界用例自测清单和推导思路，查漏补缺。无论哪种情况，我保证你读完以后，再遇到这类“移动棋子、交换位置、凑连续”的题目，第一反应不是赶紧写个暴力模拟，而是先想想能不能用数学直接走到终点。

1. 题目到底在问什么：先读懂规则再动手

1.1 原始题意与三个常被忽略的隐藏条件

我先用自己的话把题目复述一遍。有三枚石子，初始位置分别是整数 a、b、c，三者互不相同。每一步操作，你可以选择任意一枚石子，把它移动到一个新的整数位置。移动后的位置只要保证三枚石子依然互不相同即可。目标状态是“三枚石子连续”，也就是它们最终分布在三个相邻的整数上，例如位置 7、8、9。要求返回一个长度为 2 的数组，第一项是最小移动次数，第二项是最大移动次数。

很多同学看完题就马上想：那我直接模拟啊，每一步枚举每颗石子的所有可能落点，BFS 搜到连续状态不就行了？如果初始数据范围很小，这个思路确实能跑通。但这道题的精髓恰恰在于：你需要的不是“怎么搜”，而是“总共有哪几种情况”。所以读题时建议先抠清楚三个隐藏条件：

• 第一，移动后的位置必须和另外两颗石子都不同。换句话说，你不能把一颗石子移到别人已经站的位置上，这其实限制了很多“看似一步到位”的操作。
• 第二，目标状态“连续”并没有指定必须落在什么区间。三颗石子可以整体平移，比如初始数轴上其他位置也有空间，所以最终连续的位置不必局限于原最小值和最大值之间。但这并不影响最简推导，因为最短路径不会离开原始区间，这点后面讲最大次数时会再次体现。
• 第三，操作次数没有上限，也没有说每次只能移动一格。你完全可以把一颗石子从 1 号位直接甩到 100 号位，只要落点不与其他石子冲突。那么“最大移动次数”这个说法，考察的其实是：在可以任意跳的情况下，如何通过“合理拖延”让操作数达到最多。

我一直强调先把规则剥开，是因为大部分错误提交，问题都不出在公式上，而是规则理解有偏差。比如有人会误以为一次只能移动一格，得出错误的最大次数；也有人以为最终连续位置必须包含原来中间那颗石子，导致最小次数判断错误。这些坑我后面都会详细展开。

1.2 为什么这道题不能直接模拟

既然数据范围不大（我记得约束里位置在 -100 到 100 之间），BFS 严格来说可行，但用 BFS 就相当于主动放弃思考的机会。这道题的输入只有三个整数，穷举所有移动步骤当然能出结果，可一旦你把它当作搜索题来做，就很容易把同样的问题带到更复杂的后续题目里。

打个比方，模拟法解决这道题就像是数一堆硬币时一个一个数，虽然肯定能数对，却忽略了“五个五个一摞”的快捷方式。面试和竞赛里考这类题，不是真的在乎你能不能写出一个状态压缩 BFS，而是想看你能不能从混乱的操作里提炼出不变的东西——我们叫它“不变量”或者“上界/下界”。一旦你意识到：无论怎么移动，任意两颗石子的相对位置关系只有“距离为 1”“距离为 2”“距离大于 2”这三种本质情况，题目就已经解掉一半了。

另外，如果真去写 BFS，状态去重还需要处理坐标偏移、三层循环枚举落点，代码量不小，还容易因为个别状态没去重导致超时。这道题真正值得做的地方，在于它用最简单的形式告诉你：很多“操作类”题目，最先应该问的是“这个操作的空间有多大”，而不是“我该怎么枚举每个操作”。

2. 核心思路拆解：为什么这道题是数学题而不是模拟题

2.1 最大移动次数：空位总数就是答案

先把三枚石子按从小到大排序，记为 x < y < z。我在草稿纸上最先把目光放在了“跨度”上：初始状态下，最左和最右石子的跨度是 z - x，而目标连续时，跨度一定等于 2，也就是三颗石子占据 x'、x'+1、x'+2 三个位置。

现在思考最大移动次数。每一次移动，如果我们只想让局面朝着连续方向“缓慢推进”，最省步数的推进方式是什么？是把横跨区间两端之一的那颗石子，向中间方向移动刚好一格。举个例子：x=1，y=5，z=9，把 x 从 1 移到 2，或者把 z 从 9 移到 8。这样操作一次，总跨度 z-x 只减少 1。反过来，如果你一次把 x 从 1 移到 4，跨度一下子就减少 3，这种操作虽然合法，但“太有效率”了，会让总步数变少，拿不到最大次数。

所以我们追求最大次数时，可以故意采用“每次只挪一格”的策略。初始跨度是 z-x，目标跨度是 2，每一步把跨度减小 1，那么至少需要 (z-x) - 2 步才能把跨度从初始值压到 2。同时这个步数不是纸上谈兵，它是可以构造出来的：把 x 一步步向右挪到 y-1，再把 z 一步步向左挪到 y+1，最后三颗石子就会停在 y-1、y、y+1，连续完成。x 向右挪到 y-1 需要 (y-x-1) 步，z 向左挪到 y+1 需要 (z-y-1) 步，加起来正好等于 (z-x-2)。

我刚做这题时，第一反应是“最大次数 = 两两距离之和再减点什么”，后来发现这个式子就是“空位数”。什么空位？在区间 [x, z] 内一共有 z-x+1 个整数位置，其中 3 个位置被石子占据，剩下的空位数量是 (z-x+1) - 3 = z-x-2。这恰好等于最大移动次数。用生活场景来理解：把区间想象成一排车位，3 辆车停在里面，你想让三辆车正好停在相邻的三个车位上，而且你愿意反复折腾，那么每多停进一个靠近中间的空位，就相当于把车往中间挪一步，总空位数就是你能折腾的极限步数。

2.2 最小移动次数：三句话讲完所有情况

最小移动次数的关键洞察是：三颗石子最多只需要 2 步就能连续。为什么？因为任何时候你都可以固定中间那颗石子不动，把最左的石子移到 y-1，把最右的石子移到 y+1。只要这两颗石子原本不在 y-1 和 y+1 上，两步一定完成。那什么时候不需要 2 步？分三种情况：

• 第一种情况：已经连续。也就是 z-x=2，三颗石子本来就占着三个相邻位置，最小移动次数是 0。
• 第二种情况：存在两颗石子的距离 ≤ 2，但又不是完全连续。这里要稍微留意：两颗相邻（距离为 1）或中间隔了一个空位（距离为 2）都算。如果两颗石子相距 1，比如 1 和 2，那把第三颗石子移到 3，一步完成；如果两颗石子相距 2，比如 1 和 3，中间空着 2，那把第三颗石子移到 2，也是一步完成。所以这种情况最小移动次数是 1。
• 第三种情况：任意两两距离都大于 2，也就是排序后 y-x > 2 且 z-y > 2。这时没有任何一对石子靠近，一步之内无法构建出连续三连，答案就是 2。

我这样表述，比单纯背“看是否有距离小于等于2的石子对”要更安全，因为第二种情况里有两个细节容易漏：一是完全连续必须先排除，否则会误判成 1；二是“存在一对石子距离 ≤ 2”这个条件，必须同时检查 x 和 y、y 和 z 两对，只检查其中一对会漏掉对称情况。

如果写成判定式，逻辑就是：

• 如果 z-x == 2，最小次数是 0；
• 否则，如果 y-x <= 2 或 z-y <= 2，最小次数是 1；
• 否则，最小次数是 2。

我特别喜欢这个分支结构，因为它把复杂操作问题压缩成了一个三段式判断。 这里每一条分支都有严格的构造方案，不是凭感觉猜的。之前我看评论有人说“最小次数不是 0 就是 1 就是 2，这题不是送分吗”，确实，答案范围很小，但能完整、不重不漏地分对，才是考点。

2.3 为什么排序以后问题会变简单

题目给的三个变量是 a、b、c，但它们在数轴上顺序是乱的。如果你不排序，判断逻辑会非常痛苦，因为你得考虑 a 是不是最小值、b 是不是中间值等各种排列。我一开始就踩过这个坑：我试图写“if abs(a-b) == 1 or abs(b-c) == 1”这种判断，结果面对 a=c-2、b 在另一端的情况时，自己被绕晕了。

排序之后就非常清爽：令 x=min(a,b,c)，z=max(a,b,c)，剩下的自然就是 y。然后所有判断都围绕两段间隔（y-x）和（z-y）展开。排序这个行为看似微不足道，但它是这类“数轴上几个点”题目的标准动作。无论是求连续区间、求最小覆盖，还是计算相邻间距，先排序几乎总是能把讨论量减半，因为位置关系从“谁在中间”变成“从左到右编号 1、2、3”，后续所有公式都建立在统一的坐标上。

这里我还想补充一个反直觉的小点：排序后我们只关心间距，却不关心石子具体落在哪个坐标。这意味着不管 a、b、c 是 1、100、50 还是 -99、0、99，只要排序后的间距相同，答案就相同。这个性质在题目中很隐蔽，但理解了它，你就能接受“为什么代码可以这么短”——因为正确答案根本不依赖坐标绝对值，只依赖相对间隔。

3. 代码实现与细节：从公式到多语言落地

3.1 Python 版本：四行搞定核心逻辑

Python 写这题非常舒服，排序可以借助内置 sorted，一行完成。下面是我最终提交的版本：

python复制from typing import List

class Solution:
    def numMovesStones(self, a: int, b: int, c: int) -> List[int]:
        x, y, z = sorted([a, b, c])
        if z - x == 2:
            return [0, 0]
        min_moves = 1 if (y - x <= 2 or z - y <= 2) else 2
        max_moves = z - x - 2
        return [min_moves, max_moves]

这段代码里最容易忽略的是第一行的 from typing import List，LeetCode 的 Python3 环境通常不会自动帮你注入 List 类型，如果你在本地 IDE 直接跑，不加这行会报 NameError。 我最初在本地测试时就卡在这里，还以为是算法写错了，后来才发现是类型注解的问题。

再看判断顺序。先判断 z - x == 2，返回 0 和 0，这其实是把“已经连续”这个特殊情况提前拦住了。这样后面计算 min_moves 时，就不用担心“已经连续但 y-x<=2 也成立”导致的误判。如果把 if z - x == 2 放到最后，那前面对 y-x 和 z-y 的判断就必须额外排除连续情况，代码就没这么优雅了。

3.2 Java 版本与 C++ 的注意点

如果你用 Java 写，思路完全一样，但有几个语法细节值得提醒。下面是我本地跑过的版本：

java复制import java.util.Arrays;

class Solution {
    public int[] numMovesStones(int a, int b, int c) {
        int[] arr = new int[]{a, b, c};
        Arrays.sort(arr);
        int x = arr[0], y = arr[1], z = arr[2];

        if (z - x == 2) {
            return new int[]{0, 0};
        }

        int minMoves = (y - x <= 2 || z - y <= 2) ? 1 : 2;
        int maxMoves = z - x - 2;
        return new int[]{minMoves, maxMoves};
    }
}

Java 版本需要注意，Arrays.sort 是原地排序，所以先新建一个长度为 3 的数组，再排序，随后从数组下标取 x、y、z。这里没有直接用 a、b、c 变量，是因为我们想要的是排序后的顺序，而不是原变量名。

C++ 版本我一般会这么写：

cpp复制class Solution {
public:
    vector<int> numMovesStones(int a, int b, int c) {
        vector<int> v = {a, b, c};
        sort(v.begin(), v.end());
        int x = v[0], y = v[1], z = v[2];

        if (z - x == 2) return {0, 0};

        int minMoves = (y - x <= 2 || z - y <= 2) ? 1 : 2;
        int maxMoves = z - x - 2;
        return {minMoves, maxMoves};
    }
};

C++ 这里要特别小心 sort 和 vector 的头文件。在 LeetCode 环境里这些通常已经包含，但你在本地用纯 C++ 文件编译时，记得加上 #include <vector> 和 #include <algorithm>。这是很多初学者在本地跑 LeetCode 代码时最常见的编译错误。

3.3 一行代码判断连续：z-x == 2 的优雅之处

为什么判断“已经连续”用的是 z - x == 2，而不是检查 y - x == 1 && z - y == 1？两者逻辑上等价，但前者更简洁。三个互不相同的整数，如果最大值和最小值之差只有 2，那么中间那个整数必然被唯一剩下的位置占据，三颗石子不可能不连续。这就好像一条长度为 2 的线段上有 3 个不同的整数点，它们只能填满整段。

我提交之前特意验证了极端情况，比如 a=1、b=2、c=3，这时候 x=1、z=3，z-x=2，返回 [0,0]。再比如 a=1、b=2、c=4，排序后 x=1、y=2、z=4，z-x=3，不满足连续，进入后面的判断。y-x=1，所以最小次数为 1，最大次数为 4-1-2=1。也就是说，[1,2,4] 这组输入必须移动一次，且最多也只能移动一次，比如把 4 移到 3 就连续了。这个例子能直观帮你验证代码的返回是否符合直觉。我就是靠这种“拿小例子手算一遍”的方式，确认代码没问题才提交的。

4. 常见问题与踩坑实录：那些“想当然”的瞬间

4.1 误区一：最小次数总想成 2，忽略了本来就有相邻石子

我见过很多题解讨论区的新人，上来就写 return new int[]{2, ...}，理由是三颗石子怎么都得挪两下才能连续。这个想法错在忽略了“初始状态已经有两颗石子相邻”的情况。举一个最直接的例子：输入是 1、2、100。肉眼可见，1 和 2 已经挨在一起，第三颗石子跑到 3，三步变一步。如果统一返回 2，答案就错了。

这个问题在思维上叫“没有把初始状态纳入分类”。我们处理算法题时，默认总想从一般情况推导，但边界条件往往是题目的陷阱所在。我的建议是，写完代码后至少要跑三个自测用例：一个完全连续（答案 0）、一个存在相邻石子（答案 1）、一个三颗石子距离都大于 2（答案 2）。这三个用例一测，最小次数分支就不容易漏。

4.2 误区二：最大次数算成 z-x-1 或 (z-x)/2

最大次数也是重灾区。有人觉得三颗石子之间的总跨度是 z-x，目标是跨度 2，所以直接用 z-x-2。这个没问题，但有些人会手滑写成 z-x-1，他们会想当然认为三颗石子占三个位置，所以区间长度减 1 就是最大步数。实际上，区间 [x,z] 内一共有 z-x+1 个位置，去掉 3 个占位，空位数是 z-x-2。如果你把公式理解成“所有空位都要被一步步填掉”，就不会记错这个 2 到底是哪里来的。

还有人会试图用 (z-x)/2 这种近似公式，这显然更离谱。最大次数根本不是“半径”或者“一半跨度”，它跟石子之间两个间隔的总和相关。例如排序后是 1、10、11，间距分别是 9 和 1，那么 z-x-2 = 11-1-2 = 8。这个结果等于左段空位数 8 加上右段空位数 0，很符合直觉：右边已经相邻，主要工作是把最左的石子一步一步挪到中间石子旁边，但它不可能直接挪到 9 号位，需要避开中间石子在 10 号位，所以最左石子最多挪到 9 号位，从 1 到 9 需要 8 步。

4.3 边界用例自测清单

为了减少试错成本，我每次整理这类题都会保留一组自测用例。这题的测试用例不多，我建议至少覆盖以下几种情况：

这张表里的第五行和第六行很有价值，它们能帮你验证最大次数公式。比如 [1,4,7]，z-x-2 = 4，说明最大步数是 4，最小步数是 2。你可以尝试在纸上构造一条 4 步的路径：1,4,7 → 1,4,6 → 2,4,6 → 2,4,5 → 3,4,5。这个构造过程体现了“每次都只挪一格”的拖延策略。

4.4 实际调试过程复盘：一次错误提交的完整记录

说一个我自己真实犯过的错误，非常典型。最开始我把最小次数判断写成：

python复制if y - x == 1 and z - y == 1:
    return [0, 0]
min_moves = 1 if (y - x == 1 or z - y == 1) else 2

这个版本漏掉了“间隔为 2”的情况。测试用例 1,3,5 传入后，y-x=2、z-y=2，都不等于 1，于是最小次数被错误地算成 2，但正确答案是 1（把 5 移到 2 即可）。那次提交直接 WA，我才反应过来：我们找的是“一步之内能否构造连续”，而一步之内能完成连续的条件不只有两颗石子相邻，还包括两颗石子中间恰好空一个位置。因为中间那个空位是现成的“落脚点”，第三颗石子可以直接跳进去。

后来我把判断条件改成 y - x <= 2 or z - y <= 2，一次通过。这个“从 ==1 改成 <=2”的细小改动，就是整道题最容易翻车的地方。我在题解区也看到不少人卡在这个细节上，所以特意把它拎出来复盘。

5. 延伸思考：从 1033 到一类题的解题模式

5.1 类似题目与进阶版本：移动石子直到连续 II

做完 1033 之后，我很自然地想到同系列还有一道进阶题，LeetCode 1040，Moving Stones Until Consecutive II。那道题不再是三个石子，而是一排石子（个数可达 10^4），每次移动规则也更复杂。它要求计算最小次数和最大次数，解法里用到了滑动窗口和贪心，核心思想还是“考虑连续区间的长度”和“初始最左/最右石子的位置关系”。如果你喜欢 1033 这种“数学推导+分类讨论”的风格，1040 是很好的下一道练习。

但我不建议一上来就啃 1040。先把 1033 的思考方式吃透，至少你要能脱口而出“最小次数看是否已经连续或者存在距离 ≤2 的石子对，最大次数等于区间空位数”。这个思维模型在 1040 里同样起作用，只是石子变多以后，“最大次数”不再是一个简单减法，而是需要比较“从左边连续扫描”和“从右边连续扫描”两种方案的代价。有了 1033 的底子，你再理解 1040 的代码就会顺畅很多。

5.2 分类讨论题的通用套路：先特判再通解

这类题做多了，我总结出一个通用套路：先问自己三个问题。第一个问题：什么情况一步都不用做？第二个问题：什么情况一步就能完成？第三个问题：如果以上都不满足，两步甚至更多步怎么做？这个“0、1、N”的递进式分类，特别适合目标是“最小操作次数”的题目。

另一个重要习惯是“先特判再通解”。比如 1033 里我先把 z-x==2 的连续情况 return 掉，这样后续公式就不用背着特判的包袱。很多同学喜欢把所有情况写在一个大 if 表达式里，逻辑也能对，但代码可读性和可维护性会差很多。尤其是在面试白板题里，面试官更希望看到你先把边界单独拿出来处理，再讨论一般情况。这个习惯看起来简单，实际能帮你减少大量边界 bug。

5.3 我在刷题中的时间分配经验：别在 Easy 题上盲目恋战

回到“耗时 100”这个标题。我现在回头看，这道题如果思路正确，从读题到 AC 不会超过十分钟。为什么有人会耗上 100 分钟？大概率是把时间浪费在了反复试探错误公式上，而不是先停下来枚举几种典型输入。我自己的经验是，刷题遇到“移动石子”“翻转字符串”“凑等式”这类操作题时，先在草稿纸上写三个具体例子跑一遍，比闷头改代码高效得多。

具体到 LeetCode 周赛，一般前两道题都是这种偏数学规律或模拟的 Easy/Medium，时间分配上我习惯给第一题最多十分钟，超过十分钟没思路就先跳到下一题。这并不是放弃，而是避免陷入“沉没成本”——很多人在一道 Easy 题上耗久了，后面题目根本没时间看，导致整场比赛崩盘。 1033 这种题就是典型的“看着简单、想复杂就完蛋”，所以更应该在初步分析后快速决定：要么用数学一步到位，要么马上换策略。

5.4 学习迁移：把“连续三数”模型用到其他场景

最后我想说一个比较实用的迁移角度。1033 这个模型本质上是“三个点通过最少的移动变成连续段”，在现实里可以映射成不少调度问题。比如三台机器需要把任务节点调整到相邻工位上，或者三个传感器需要落在一个覆盖窗口内，最小调整次数和最大调整次数都可以用这段区间分析来估算。当然实际工程里还有更多约束，但这个“先看间距再看跨度”的思维方式是通用的。

我做这类题最大的收获，不是记住一个公式，而是养成了一种条件反射：当问题的状态空间看起来只有两三个变量时，先不要急着搜索，列出所有可能的关系，往往答案就藏在一张两行三列的小表里。这种能力在面试中尤其值钱，因为面试官想看的就是你拆解问题的条理，而不是能不能背下 BFS 模板。我自己在一次模拟面试里就遇到类似的变种题，当时正是靠着 1033 练出来的分类讨论思路，很快就把最小最大值讲清楚了。

如果你刷完这道题也有同感，可以顺手试试 1040，看看自己能不能用同样的分类思路啃下那层更硬的壳。至少对我来说，这种由浅入深的系列题，比漫无目的地刷 100 道不相关题目更能巩固算法思维。