josephus环公式法

4. m 为 2 的情况
现在考虑一种 m 为 2 的特殊情形。 这时候有更简单的递归公式：
x = 2*n + 1 - (2*n+1-2*k)*2^log2((2*n)/(2*n+1-2*k))
其中，log2((2*n)/(2*n+1-2*k)) 为计算(2*n)/(2*n+1-2*k)以 2 为底的对数， 结果向下取整数。
联系 2^log2((2*n)/(2*n+1-2*k))整体，可以理解为将(2*n)/(2*n+1-2*k)向下 舍取到 2 的幂。有些地方把这中 运算称为地板函数，我们定义为 flp2，下面是 C 语言的实现：
unsigned flp2(unsigned x) { unsigned y; do { y = x; x &= x-1; }while(x); return y;
} 其中 x &= x-1;语句是每次把 x 二进制最右边的 1 修改为 0，直到最左边的 1 为止. 这种方法也可以用来计算 x 二进制中 1 的数目，当 x 二进制中 1 的数目比较小的 时候算法的效率很高。
m 为 2 的代码实现:
unsigned josephus2k(unsigned n, unsigned k) { unsiged t = (n<<1) - (k<<1) + 1; return (n<<1)+1 - t*flp2((n<<1)/t); }
unsigned josephus(unsigned m, unsigned n, unsigned k) { unsigned x = km; while(x <= n) x = (m*(x-n)-1)/(m-1); return x; }
unsigned flp2(unsigned x) { unsigned y; do { y = x; x &= x-1; }while(x); return y; }
有了这个公 式，我们要做的就是从 1-n 顺序算出 f[i]的数值，最后结果是 f[n]。因为实际生活 中编号总是从 1 开始，我们输出 f[n]+1
由于是 逐级递推，不需要保存每个 f[i]，程序也是异常简单：
＃i nclude <stdio.h>
main() { int n, m, i, s=0; printf ("N M = "); scanf("%d%d", &n, &m); for (i=2; i<=n; i++) s=(s+m)%i; printf ("The winner is %d\n", s+1); }
Out.println( "Survivor is " + x.val); } }
3. 递归公式
喜欢这个问题的朋友肯定不满足上面的方法，很想知道更简单的算法。 其实 Josephus 问题中的序列确实存在递归 的公式。但是递归公式的推导 比较麻烦，我就直接给出结果。如果想了解详细过程可以查阅相关资料。
Node t = new Node(1); Node x = t;
for (int i = 2; i <= N; x = (x.next=new Node(i++))); x.next = t;
while (x != x.next) { for (int i = 1; i < M; i++) x = x.next; x.next = x.next.next; }
从 二进制的角度可以理解为： 将 n 左移 1 位（即乘以 2），然后将最右端设置为 1（既加 1）， 最后将左端的 1 置为 0（既减去 2*n 的向下取的 2 的幂）。
更简单的描述是将 n 的二进制表示循环右移动一位! 例如: n 为 1011001 -> 0110011 -> 110011
josephus 环公式法
Josephus(约瑟夫)问题的数学方法(转)2010-06-25 3:08Josephus 问 题
1. 问题的由来
Josephus 问题是以 10 世纪的著名历史学家 Flavius Josephus 命名的. 据说, Josephus 如果没 有数学才能, 他就不会在活着的时候出名! 在犹太人和古罗马人战争期间, 他是陷 如罗马人陷 阱的 41 个犹太反抗者之一. 反抗者宁死不做俘虏, 他们决定围成一个圆圈,且围绕圆圈来进行, 杀死所有第 3 个剩下的人直到没有一个人留下. 但是, Josephus 和一个不告发的同谋者感到自 杀是愚蠢的行为, 所以以他快速计算出在此恶性循环中他和他的朋友应该站的地方. 因此, 他们 活了下来...
Node t = new Node(1); Node x = t;
for (int i = 2; i <= N; x = (x.next=new Node(i++))); x.next = t;
while (x != x.next) { for (int i = 1; i < M; i++) x = x.next; x.next = x.next.next; } Out.println("Survivor is " + x.val); } }
5. m 为 2 的情况, k 为 n 的情形
该问题一般都是计算最
后一个被杀的人的位置。 现在考虑更为特殊的，m 为 2 的情况, k 为 n 的情形。
令 k=n 可以化简前边 m=2 的公式：
x = 2*n + 1 - (2*n+1-2*n)*2^log2((2*n)/(2*n+1-2*n)) 即，x = 2*n + 1 - 2^log2(2*n)
这 个算法的时间复杂度为 O(n)，相对于模拟算法已经有了很大的提高。算 n，m 等于一百万， 一千万的情况不是问题了。可见，适当地运用数学策略，不仅可以让 编程变得简单，而且往往 会成倍地提高算法执行效率。
在网上看到这个，好像就是 wywcgs 高人 说的约瑟夫问题的高效解法！这个方法太妙了！ 想到我们学校的 4022-Recursive Survival。想应该可以用这个方法解决。 刚 开始没太细想，就直接这个方法，结果肯定超时（两个数的范围在 2^63-1）。 就想这个约瑟夫问题的高效解法关键是找到第 n 跟 n-1 的递推关系 x‘=(x+k)%n。它是每次 去掉第一个人，在构成 一个新队列，而且队列有一定的规律 k k+1 k+2 ... n-2, n-1, 0, 1, 2, ... k-2。 而这道题是每 2 个人去掉一个，如果从整个队列 1 2 3 ...... n,来考虑，把整个队列都数一遍的 话，剩下的是： 1 3 5 7 ...... n-1 (n 为偶数，且下一次相当于从 1 开始重新数) 1 3 5 7 ...... n (n 为奇数，且下一个去掉的是 1，也就是说相当于从 3 开始数)。 由此得到关于 n 的递推公式 n=2*f(n/2)-1(n 为偶数); n=2*f(n/2)+1(n 为奇数). 这样即使 n=2^63-1,最多也只要 63 次递归. 当时，觉得已经想的差不 多了，一提交，还是超时呢！ 一细想，忘了考虑 m,the times of the function nested。 如果 m=2^63-1,这么做是没法想像的。就如果 n=1 时，m 就不需要考虑，直接就可以出来. 如果 n 递减也比较快可以出来（只是自己认为如此）。如 果 n 个人时剩下的是 n,那就要把 m 都 用完。 所以加了个判断语句就 OK 呢！ 结果真的给 AC 呢，用了 0.03 秒。 不过看了别人的提交 纪录，只用了 0.00 秒，而且我的占用内纯是别人的好几倍。
用代码实现为：
unsigned josephus2n(unsigned n) { return ((n-flp2(n))<<1)|1; }
===================
class Josephus
{ static class Node { int val; Node next; Node(int v) { val = v; } } public static void main(String[] args) { int N = Integer.parseInt(args[0]); int M = Integer.parseInt(args[1]);
无论是用链表实现还是用数组实现都有一个共同点：要模拟整个游戏过程，不仅程序写起来比较 烦，而且时间复杂度高达 O(nm)，当 n，m 非常大(例如上百万，上千万)的时候，几 乎是没有 办法在短时间内出结果的。我们注意到原问题仅仅是要求出最后的胜利者的序号，而不是要读者 模拟整个过程。因此如果要追求效率，就要打破常规，实施 一点数学策略。 为了讨论方便，先把问题稍微改变一下，并不影响原意：
现在我们把他们的编号做一下转换：
k
--> 0
k+1 --> 1
k+2 --> 2
...
...
k-2 --> n-2
k-1 --> n-1
变换后就完完全全成为了(n-1)个人报数的子问题，假如我们知道这个子问题的解：例如 x 是最 终的胜利者，那么根据 上面这个表把这个 x 变回去不刚好就是 n 个人情况的解吗？！！变回去 的公式很简单，相信大家都可以推出来：x‘=(x+k)%n