约瑟夫问题的几种解法

问题来历

据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。问题是，给定了和，一开始要站在什么地方才能避免被处决？Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。

最直观的解法是用循环链表模拟报数、淘汰的过程，复杂度是O(NM)。
这种方法算法复杂度比较大，下面介绍两种复杂度较为简单的方法

方法一
令f[n]表示当有n个候选人时，最后当选者的编号。
f[1] = 0
f[n] = (f[n - 1] + K) mod n

接下来我们用数学归纳法来证明这个递推公式的正确性：
(1) f[1] = 0
显然当只有1个候选人时，该候选人就是当选者，并且他的编号为0。
(2) f[n] = (f[n - 1] + K) mod n
假设我们已经求解出了f[n - 1]，并且保证f[n - 1]的值是正确的。
现在先将n个人按照编号进行排序：
0 1 2 3 … n-1
那么第一次被淘汰的人编号一定是K-1(假设K < n，若K > n则为(K-1) mod n)。将被选中的人标记为”#”：
0 1 2 3 … K-2 # K K+1 K+2 … n-1
第二轮报数时，起点为K这个候选人。并且只剩下n-1个选手。假如此时把k+1看作0’，k+2看作1’…
则对应有：

0	1	2	3	…	K-2	#	K	K+1	K+2	…	n-1
n-K’					n-2’		0’	1’	2’	…	n-K-1’

此时在0’,1’,…,n-2’上再进行一次K报数的选择。而f[n-1]的值已经求得，因此我们可以直接求得当选者的编号s’。
但是，该编号s’是在n-1个候选人报数时的编号，并不等于n个人时的编号，所以我们还需要将s’转换为对应的s。
通过观察，s和s’编号相对偏移了K，又因为是在环中，因此得到s = (s’+K) mod n。
即f[n] = (f[n-1] + k) mod n。

至此递推公式的两个式子我们均证明了其正确性，则对于任意给定的n，我们可以使用该递推式求得f[n]，写代码为：

int Josephus(int n, int k){
    f[1] = 0;
    for (int i = 2; i <= n; i++){
        f[i] = (f[i-1] + k)%i;
    }
    return f[n];
}

同时由于计算f[i]时，只会用到f[i-1]，因此我们还可以将f[]的空间节约，改进后的代码为：

int Josephus(int n, int k){
    int ret = 0;
    for (int i = 2; i <= n; i++){
        ret = (ret + k)%i;
    }
    return ret;
}

该算法的时间复杂度为O(N)，空间复杂度为O(1)。对于N不是很大的数据来说，可以解决。

方法二
如果当n特别大的时候，上面那个算法的规模还是太大，我们可以用另一种方法来算
初始N=10,K=4:
初始序列：
0 1 2 3 4 5 6 7 8 9
当7号进行过报数之后：
0 1 2 - 4 5 6 - 8 9
在这里一轮报数当中，有两名候选人退出了。而对于任意一个N,K来说，退出的候选人数量为N/K(“/”运算表示整除，即带余除法取商)
由于此时起点为8，则等价于：
2 3 4 - 5 6 7 - 0 1
因此我们仍然可以从f[8]的结果来推导出f[10]的结果。
但需要注意的是，此时f[10]的结果并不一定直接等于(f[8] + 8) mod 10。
若f[8]=2，对于原来的序列来说对应了0，(2+8) mod 10 = 0，是对应的；若f[8]=6，则有(6+8) mod 10 = 4，然而实际上应该对应的编号为5。
这是因为在序列(2 3 4 - 5 6 7 - 0 1)中，数字并不是连续的。
因此我们需要根据f[8]的值进行分类讨论。假设f[8]=s，则根据s和N mod K的大小关系有两种情况：
1) s < N mod K : s’ = s - N mod K + N
2) s ≥ N mod K : s’ = s - N mod K + (s - N mod K) / (K - 1)
此外还有一个问题，由于我们不断的在减小N的规模，最后一定会将N减少到小于K，此时N/K=0。
因此当N小于K时，就只能采用第一种递推的算法来计算了。
最后优化方法的代码为：

int Josephus(int n, int k){
    if (n == 1){
        return 0;
    }
    if (n < k){
        int ret = 0;
        for (int i = 2; i <= n; i++){
            ret = (ret+k)%i;
        }
        return ret;
    }
    int ret = Josephus1(n-n/k, k);
    if (ret < n%k){
        ret = ret-n%k+n;
    }else{
        ret = ret - n%k + (ret-n%k)/(k-1);
    }
    return ret;
}

改进后的算法可以很快将N的规模减小到K，对于K不是很大的问题能够快速求解。