转：【整理】约瑟夫问题的数学方法

之前就知道约瑟夫问题是模拟，今天我才发现一些约瑟夫问题可使用数学解法得出！真是强悍啊！约瑟夫问题真是博大精深！固然报数长度不定的应该只有模拟了吧，能用数学作的都是简化过的约瑟夫问题。

下面整理以下：

1.问题描述：n我的（编号1~n)，从1开始报数，报到m的退出，剩下的人继续从1开始报数。按顺序输出列者编号。数学解法复杂度：O(n)。

 

下面的代码摘自雨中飞燕博客，这个公式推的太牛了，我还没看懂。。。

 

#include <stdio.h>

#include <conio.h>

int main( void )

{

     int n, i = 0, m, p;

     scanf("%d%d", &n, &m); //n总人数，m步长

     while( ++i <= n )

     {

         p = i * m;

         while (p > n)

             p = p - n + (p - n - 1)/(m - 1);

         printf("%d/n", p);

     }

     getch();return 0;

}

2.问题描述：n我的（编号1~n)，从1开始报数，报到m的退出，剩下的人继续从1开始报数。求胜利者的编号。数学解法复杂度：O(n)。

多重转载，做者不明，但写得至关好。。。

不管是用链表实现仍是用数组实现都有一个共同点：要模拟整个游戏过程，不只程序写起来比 较烦，并且时间复杂度高达O(nm)，当n，m很是大(例如上百万，上千万)的时候，几乎是没有办法在短期内出结果的。咱们注意到原问题仅仅是要求出最 后的胜利者的序号，而不是要读者模拟整个过程。所以若是要追求效率，就要打破常规，实施一点数学策略。

为了讨论方便，先把问题稍微改变一下，并不影响原意：

问题描述：n我的（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。求胜利者的编号。

咱们知道第一我的(编号必定是m%n-1) 出列以后，剩下的n-1我的组成了一个新的约瑟夫环（以编号为k=m%n的人开始）:

   k   k+1   k+2   ... n-2, n-1, 0, 1, 2, ... k-2

而且从k开始报0。

如今咱们把他们的编号作一下转换：

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

如何知道(n-1)我的报数的问题的解？对，只要知道(n-2)我的的解就好了。(n-2)我的的解呢？固然是先求(n-3)的状况 ---- 这显然就是一个倒推问题！好了，思路出来了，下面写递推公式：

令f[i]表示i我的玩游戏报m退出最后胜利者的编号，最后的结果天然是f[n]

递推公式

f[1]=0;

f[i]=(f[i-1]+m)%i;   (i>1)

有了这个公式，咱们要作的就是从1-n顺序算出f[i]的数值，最后结果是f[n]。由于实际生活中编号老是从1开始，咱们输出f[n]+1

因为是逐级递推，不须要保存每一个f[i]，程序也是异常简单：

#include <stdio.h>

int 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);

}

这个算法的时间复杂度为O(n)，相对于模拟算法已经有了很大的提升。算n，m等于一百万，一千万的状况不是问题了。

3.问题描述：n我的（编号1~n)，从1开始报数，报到m(m<<n)的退出，剩下的人继续从1开始报数。求胜利者的编号。数学解法优化后复杂度：O(m)。

一样摘自互联网，貌似是一篇论文，做者不明。。。

上面的算法相比最初的模拟算法效率已经大大提高了，那么，该算法还有改进的余地么？

事实上，若是咱们观察上述算法中的变量s，他的初始值为第一个出圈人的编号，但在循环的过程当中，咱们会发现它经常处在一种等差递增的状态，我来看这个式 子：s=(s+m)%i;，能够看出，当i比较大而s+m-1比较小的时候，s就处于一种等差递增的状态，这个等差递增的过程并非必须的，能够跳过。

咱们设一中间变量x，列出以下等式：

s+m*x–1=i+x

解出x，令s=s+m*x，将i+x直接赋值给 i，这样就跳过了中间共x重的循环，从而节省了等差递增的时间开销。但是其中求出来的x＋i可能会超过n，这样的结果事实上已经告诉咱们此时能够直接结束算法了。 

 

整个算法的C语言描述以下：

long Josephus(long n,long m,long k) //分别为：人数，出圈步长，起使报数位置,

{

    if (m == 1)k = k == 1 ? n : (k + n - 1) % n;

    else

    {

        for (long i = 1; i <= n; i++)

        {

            if ((k + m) < i)

            {

                x = (i - k + 1) / (m - 1) - 1;

                if (i + x < n)

                {

                    i = i + x;

                    k = (k + m * x);

                }

                else

                {

                    k = k + m * (n - i) ;

                    i = n;

                }

            }

            k = (k + m - 1) % i + 1;

        }

    }

    return k; //返回最后一人的位置

}

该算法的算法复杂度在m<n时已经与一个圈中的人数n没有关系了，即便在n=2000000000，m=3，s=1的状况下，也只作了54次循环，事 实上，大多数的状况都是m<n，且m相对来讲很小，此时，这个算法的复杂度仅为O(m)；但当m>=n时，用方程求出的值不能减小循环重数，算法复杂度仍为O(n)。

4.问题描述：n我的（编号1~n)，从1开始报数，报到2的退出，剩下的人继续从1开始报数。求胜利者的编号。数学解法优化后复杂度：O(log n) 

 

详见 Donald E. Knuth的《具体数学》 中相关部分的讨论，至关精彩。（点击这里）

 

 

这时候有更简单的递归公式：

J(1) = 1;

J(2n) = 2J(n) − 1,当 n ≥ 1;    

J(2n + 1) = 2J(n) + 1,当 n ≥ 1;

进而能够推出：

 

 

J(2^m+ l) = 2l + 1,当 m ≥ 0且0 ≤ l < 2 m. 

(注意若是2^m≤ n < 2^m+1，那么余下的数l = n − 2^m知足不等式0 ≤ l <2^(m+1)− 2^m = 2^m。)

看公式蛮头疼的，其实就是找到大于N的最小的2的X次方（记为M），

而后   2N-M+1就是结果，这样编程应该很简单了吧？

 

下面来自另外一份转载，原做者不详

若是继续推下去能够获得：

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);

}