约瑟夫问题：从算法到数学的经典解析-代码聚汇网

约瑟夫问题：从算法到数学的经典解析

北陌大叔·2026-08-19·阅读 21 GEO检测（免费）

约瑟夫问题算法递归

|难度：普通|阅读约 13 分钟

1. 约瑟夫问题：从数学谜题到编程经典

第一次接触约瑟夫问题是在大学算法课上，教授用这个看似简单的游戏让我们理解了循环链表和递归的精妙。当时我花了整整一个周末才彻底弄明白其中的数学规律，但这段痛苦的思考过程却让我对算法设计有了全新的认识。约瑟夫问题不仅是信息学奥赛的常客，更是检验编程基本功的绝佳案例。

这个问题源自公元1世纪犹太历史学家弗拉维奥·约瑟夫的记载：一群犹太人被罗马军队包围，决定集体自杀。他们围坐成圈，从指定位置开始报数，数到某个特定数字的人就自杀，然后从下一个人重新报数，直到所有人自杀身亡。约瑟夫作为首领，快速计算出了自己应该坐的位置而幸存下来。这个残酷的历史故事，如今成为了计算机科学中经典的算法问题。

在信息学奥赛的赛场上，约瑟夫问题经常以各种变体出现。比如"信息奥赛一本通"中的3345题，就是最基础的约瑟夫问题形式：n个人围成一圈，从第s个人开始报数，数到m的人出列，求最后剩下的人的初始位置。这类题目考察的不仅是编码能力，更是对问题数学本质的理解。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 问题建模与算法选择

2.1 问题形式化描述

给定三个参数：

n：总人数（编号1到n）
s：起始位置（1 ≤ s ≤ n）
m：报数间隔（每次数m个人）

操作规则：

n个人围成一圈，编号1到n
从第s个人开始顺时针报数
每数到第m个人就将其淘汰
从下一个人重新开始报数
重复步骤2-4，直到只剩一人

要求输出最后剩下的人的初始编号。

2.2 暴力解法：模拟过程

最直观的方法是直接模拟整个过程。我们可以用循环链表或数组来代表人圈，然后按照规则一步步淘汰人员，直到只剩一人。这种方法虽然时间复杂度较高（O(nm)），但对于初学者来说最容易理解和实现。

python复制def josephus_simulation(n, s, m):
    people = list(range(1, n+1))
    index = s - 1  # 转换为0-based索引
    
    while len(people) > 1:
        index = (index + m - 1) % len(people)
        del people[index]
    
    return people[0]

这个实现有几个关键点：

使用列表存储人员编号
计算下一个要淘汰的人的索引：(当前位置 + m - 1) % 当前剩余人数
删除该索引对应的人员
重复直到只剩一人

注意：在实际编程竞赛中，当n和m较大时（比如n=1e6，m=1e9），这种模拟方法会因为时间复杂度过高而无法通过时间限制。这时就需要更高效的数学解法。

2.3 数学解法：递归公式

约瑟夫问题有一个优美的数学解法，可以通过递归公式直接计算出幸存者的位置。这个解法的核心思想是找到n个人和n-1个人时幸存者位置之间的关系。

递归公式：

J(n, m) = (J(n-1, m) + m) % n
基本情况：J(1, m) = 0

其中J(n, m)表示n个人、间隔为m时的幸存者索引（0-based）。

python复制def josephus_recursive(n, m):
    if n == 1:
        return 0
    return (josephus_recursive(n-1, m) + m) % n

这个递归解法的时间复杂度是O(n)，空间复杂度也是O(n)（由于递归栈）。我们可以将其改写为迭代形式来优化空间：

python复制def josephus_iterative(n, m):
    result = 0
    for i in range(2, n+1):
        result = (result + m) % i
    return result + 1  # 转换为1-based编号

这个迭代版本的时间复杂度仍然是O(n)，但空间复杂度降到了O(1)，非常适合处理大规模数据。

3. 算法优化与数学推导

3.1 数学解法的正确性证明

为什么递归公式J(n, m) = (J(n-1, m) + m) % n成立？让我们从n=1的情况开始：

当n=1时，显然幸存者就是唯一的那个人，索引为0。
对于n>1的情况，考虑第一轮淘汰：
- 从位置0开始数，第m-1个人被淘汰
- 剩下的n-1个人重新从位置m开始
- 这相当于把问题规模缩小到n-1，但起始点不同
- 因此，n-1问题的解J(n-1, m)在原始问题中的位置应该是(J(n-1, m) + m) % n

这个证明展示了如何将大规模问题分解为小规模问题，是分治思想的典型应用。

3.2 更高效的O(m log n)解法

当n非常大而m相对较小时，我们可以进一步优化算法。观察淘汰过程，当m远小于n时，可以一次计算多轮淘汰，而不需要一步步模拟。

关键思路是：计算可以跳过多少完整的m周期，直接到达下一个需要淘汰的位置。这可以将时间复杂度降低到O(m log n)。

python复制def josephus_optimized(n, m):
    if m == 1:
        return n  # 特殊情况，直接返回最后一个
    result = 0
    i = 1
    while i <= n:
        step = (i - result + m - 2) // (m - 1)
        if i + step > n:
            step = n - i + 1
        if step == 0:
            step = 1
        result = (result + m * step) % (i + step)
        i += step
    return result + 1

这个算法在m远小于n时效率极高，但在编程竞赛中，通常O(n)的迭代解法已经足够。

4. 编程实现与测试技巧

4.1 处理起始位置s≠1的情况

原问题要求从任意起始位置s开始，而我们的数学解法默认从位置1开始。要处理这种情况，只需要对结果做一个简单的调整：

python复制def josephus_general(n, s, m):
    # 先计算从1开始的解
    pos = josephus_iterative(n, m)
    # 调整起始位置
    return (pos - 1 + s - 1) % n + 1

这个调整的原理是：从s开始的解等于从1开始的解加上s-1的偏移量，然后对n取模（因为是环形）。

4.2 边界条件与特殊测试用例

在编程竞赛中，必须仔细考虑各种边界条件。对于约瑟夫问题，常见的特殊情况包括：

n=1：无论m和s是什么，结果都是1
m=1：相当于依次淘汰，最后剩下的是第n个人
s=1：标准约瑟夫问题
m=n：淘汰第m%n个人，即如果m是n的倍数则淘汰最后一个

测试用例示例：

python复制assert josephus_general(1, 1, 5) == 1
assert josephus_general(5, 1, 1) == 5
assert josephus_general(5, 3, 2) == 4
assert josephus_general(7, 1, 3) == 4
assert josephus_general(7, 2, 3) == 5

4.3 竞赛中的输入输出处理

在信息学奥赛中，题目通常会给出多组测试数据。我们需要高效地处理输入输出。以C++为例：

cpp复制#include <iostream>
using namespace std;

int josephus(int n, int m) {
    int res = 0;
    for (int i = 2; i <= n; ++i)
        res = (res + m) % i;
    return res + 1;
}

int main() {
    int n, s, m;
    while (cin >> n >> s >> m) {
        if (n == 0 && s == 0 && m == 0) break;
        int pos = josephus(n, m);
        pos = (pos - 1 + s - 1) % n + 1;
        cout << pos << endl;
    }
    return 0;
}

对于Python选手，需要注意输入处理的速度。当数据量很大时，建议使用：

python复制import sys

def main():
    for line in sys.stdin:
        n, s, m = map(int, line.split())
        if n == 0 and s == 0 and m == 0:
            break
        pos = josephus_iterative(n, m)
        pos = (pos - 1 + s - 1) % n + 1
        print(pos)

if __name__ == "__main__":
    main()

5. 问题变体与扩展思考

5.1 约瑟夫问题的常见变体

在实际竞赛中，约瑟夫问题可能有多种变体：

反向约瑟夫：逆时针报数
双向约瑟夫：交替顺时针和逆时针
步长变化：每次淘汰后m增加或减少
多幸存者：保留最后k个人而非1个

以反向约瑟夫为例，只需要调整索引计算方式：

python复制def josephus_reverse(n, m):
    result = 0
    for i in range(2, n+1):
        result = (result - m) % i
    return result + 1

5.2 约瑟夫问题的实际应用

虽然约瑟夫问题源于一个古老的故事，但它在计算机科学中有实际应用：

内存管理：某些垃圾回收算法使用约瑟夫-like的淘汰策略
进程调度：循环调度算法的变体
密码学：某些伪随机数生成器的设计
游戏设计：玩家淘汰机制的实现

5.3 进一步学习的资源

对于想深入理解约瑟夫问题的同学，推荐以下资源：

《具体数学》- 第1章递归问题中有详细讨论
Wikipedia的Josephus problem条目
信息学奥赛官方教程中的递归与数学章节
经典算法书籍中的递归与数学归纳法部分

我在最初学习约瑟夫问题时，最大的误区是过于依赖模拟方法而忽视了数学规律。直到一次竞赛中遇到n=1e6的测试用例超时后，才真正理解了数学解法的重要性。建议初学者从模拟实现开始，但一定要过渡到理解数学本质。对于竞赛选手，迭代式的数学解法应该成为肌肉记忆，能够在5分钟内正确实现。