约瑟夫斯问题

约瑟夫斯置换是一个出现在计算机科学和数学中的问题。在计算机编程的算法中，类似问题又被称为约瑟夫环。
人们站在一个等待被处决的圈子里。 计数从圆圈中的指定点开始，并沿指定方向围绕圆圈进行。 在跳过指定数量的人之后，处刑下一个人。 对剩下的人重复该过程，从下一个人开始，朝同一方向跳过相同数量的人，直到只剩下一个人，并被释放。 
问题即，给定人数、起点、方向和要跳过的数字，选择初始圆圈中的位置以避免被处决。
历史.
这个问题是以-{zh-hant:弗拉维奥·约瑟夫斯;zh-hans:弗拉维奥·约瑟夫}-命名的，他是1世纪的一名犹太历史学家。他在自己的日记中写道，他和他的40个战友被罗马军队包围在洞中。他们讨论是自杀还是被俘，最终决定自杀，并以抽签的方式决定谁杀掉谁。约瑟夫斯和另外一个人是最后两个留下的人。约瑟夫斯说服了那个人，他们将向罗马军队投降，不再自杀。约瑟夫斯把他的存活归因于运气或天意，他不知道是哪一个。
解法.
比较简单的做法是用循环单链表模拟整个过程，时间复杂度是O(n*m)。如果只是想求得最后剩下的人，则可以用数学推导的方式得出公式。且先看看模拟过程的解法。
Python版本.
class Node(object):
 def __init__(self, value):
 self.value = value 
 self.next = None
def create_linkList(n):
 head = Node(1)
 pre = head
 for i in range(2, n+1):
 newNode = Node(i)
 pre.next= newNode
 pre = newNode
 pre.next = head
 return head
n = 5 #总的个数
m = 2 #数的数目
if m == 1: #如果是1的话，特殊处理，直接输出
 print (n) 
else:
 head = create_linkList(n)
 pre = None
 cur = head
 while cur.next != cur: #终止条件是节点的下一个节点指向本身
 for i in range(m-1):
 pre = cur
 cur = cur.next
 print (cur.value)
 pre.next = cur.next
 cur.next = None
 cur = pre.next
 print (cur.value)
C++版本.
using namespace std;
typedef struct _LinkNode {
 int value;
 struct _LinkNode* next;
} LinkNode, *LinkNodePtr;
LinkNodePtr createCycle(int total) {
 int index = 1;
 LinkNodePtr head = NULL, curr = NULL, prev = NULL;
 head = (LinkNodePtr) malloc(sizeof(LinkNode));
 head-&gt;value = index;
 prev = head;
 while (--total &gt; 0) {
 curr = (LinkNodePtr) malloc(sizeof(LinkNode));
 curr-&gt;value = ++index;
 prev-&gt;next = curr;
 prev = curr;
 curr-&gt;next = head;
 return head;
void run(int total, int tag) {
 LinkNodePtr node = createCycle(total);
 LinkNodePtr prev = NULL;
 int start = 1;
 int index = start;
 while (node &amp;&amp; node-&gt;next) {
 if (index == tag) {
 printf("%d\n", node-&gt;value);
 if (tag == start) {
 prev = node-&gt;next;
 node-&gt;next = NULL;
 node = prev;
 } else {
 prev-&gt;next = node-&gt;next;
 node-&gt;next = NULL;
 node = prev-&gt;next;
 index = start;
 } else {
 prev = node;
 node = node-&gt;next;
 index++;
int main() {
 if (argc &lt; 3) return -1;
 run(atoi(argv[1]), atoi(argv[2]));
 return 0;
数学推导解法.
我们将明确解出formula_1时的问题。对于formula_2的情况，我们在下面给出一个一般的解法。
设formula_3为一开始有formula_4个人时，生还者的位置(注意：最终的生还者只有一个)。走了一圈以后，所有偶数号码的人被杀。再走第二圈，则新的第二、第四、……个人被杀，等等；就像没有第一圈一样。如果一开始有偶数个人，则第二圈时位置为formula_5的人一开始在第formula_6个位置。因此位置为formula_7的人开始时的位置为formula_8。这便给出了以下的递推公式：
如果一开始有奇数个人，则走了一圈以后，最终是号码为1的人被杀。于是同样地，再走第二圈时，新的第二、第四、……个人被杀，等等。在这种情况下，位置为formula_5的人原先位置为formula_11。这便给出了以下的递推公式：
如果我们把formula_4和formula_3的值列成表，我们可以看出一个规律：
从中可以看出，formula_3是一个递增的奇数数列，每当"n"是2的幂时，便重新从formula_16开始。因此，如果我们选择m和l，使得formula_17且formula_18，那么formula_19。注意：2^m是不超过n的最大幂，l是留下的量。显然，表格中的值满足这个方程。我们用数学归纳法给出一个证明。
定理：如果formula_17且formula_18，则formula_22。
证明：对formula_4应用数学归纳法。formula_24的情况显然成立。我们分别考虑formula_4是偶数和formula_4是奇数的情况。
如果formula_4是偶数，则我们选择formula_28和formula_29，使得formula_30，且formula_31。注意formula_32。我们有formula_33，其中第二个等式从归纳假设推出。
如果formula_4是奇数，则我们选择formula_28和formula_29，使得formula_37，且formula_31。注意formula_39。我们有formula_40，其中第二个等式从归纳假设推出。证毕。
答案的最漂亮的形式，与formula_4的二进制表示有关：把formula_4的第一位移动到最后，便得到formula_3。如果formula_4的二进制表示为formula_45，则formula_46。这可以通过把formula_4表示为formula_48来证明。
一般情况下，考虑生还者的号码从formula_49到formula_4的变化, 我们可以得到以下的递推公式(编号从0开始)：
formula_51，formula_52
这种方法的运行时间是formula_53。
程序实现（C++）
using namespace std;
//编号从0开始，也就是说如果编号从1开始结果要加1
int josephus(int n, int k) { //非递回版本
 int s = 0;
 for (int i = 2; i &lt;= n; i++)
 s = (s + k) % i;
 return s;
int josephus_recursion(int n, int k) { //递回版本
 return n &gt; 1 ? (josephus_recursion(n - 1, k) + k) % n : 0;
int main() {
 for (int i = 1; i &lt;= 100; i++)
 cout « i « ' ' « josephus(i, 5) « ' ' « josephus_recursion(i, 5) « endl;
 return 0;
对于formula_54，可以将上述方法推广，将杀掉第"k"、"2k"、……、formula_55个人视为一个步骤，然后把号码改变，可得如下递推公式, 运行时间为formula_56。
程序实现（C++）
using namespace std;
//编号从1开始，结果要加1
int josephus(int n, int k) { 
 if (k == 1) return n - 1;
 int ans = 0;
 for (int i = 2; i &lt;= n; ) {
 if (ans + k &gt;= i) {
 ans = (ans + k) % i;
 i++;
 continue;
 int step = (i - 1 - ans - 1) / (k - 1); //向下取整
 if (i + step &gt; n) {
 ans += (n - (i - 1)) * k;
 break;
 i += step;
 ans += step * k;
 return ans;
int main() {
 int n, k;
 while (scanf("%d%d", &amp;n, &amp;k) == 2)
 printf("%d\n", josephus(n, k) % n + 1);
 return 0;