约瑟夫环问题---秒级挑战长整极限（java）（一）

  前两天和朋友聊到一个题，其实对很多朋友已很熟悉：

       n个人排成圆圈，顺序排号，从第一人开始报数（从1到3报数），报到3的人退出圈子，问最后剩下几号？

    其实用数组模拟法就可以做出，但不论用什么数据结构，当n值变的很大，都会有占用巨大内存的问题，并且计算复杂度也让人无法忍受。我想出一个简单易懂的方法，不再占用大内存，也不需要什么复杂的数学推理！！！先上代码1：

import java.util.Scanner;

/**
 *
 * @author ASUS
 */
public class MyJosephus {
    public static void main(String[] args){
        long num=1,target=1;
        
        Scanner s = new Scanner(System.in);
        System.out.println("请输入排队人数");
        long n = s.nextLong();
        
        while(num<n){
            num++;
            if(num-3>=target)
                target = target + 3;
            else
                target = target + 3 - num;
        }
        System.out.println("第 "+target+"位的人留下");
    }
    
}

道理很简单：我们假设已知道n个人时，是第target个人最终留下，我们怎们推演n+1人时的情况呢？我们会先数3个人，将第三人请出，是不是就剩下n个人了，又变成n个人的问题了，对吗？只不过起点变了，不是从第一个人，而是从第四个人开始，因此我们再从第4个人往后数target，就得到新得target值。这就是程序中的 target = target + 3;。当数到底，不够数则需要转回来，就是程序中的target = target + 3 - num; 

递推式的初始值很简单，一个人当然剩下的就是他，long num=1,target=1;

是不是很简单，大家可以实验一下，象这种数都是秒级:

请输入排队人数
123456789
第 63883094位的人留下

好了，不需要占用大内存，但运算复杂度还是O(n),当我们输入巨大的n值，例如java中的long上限值9223372036854775807，它也会等待。。。。    继续优化！！！再上代码2：

import java.util.Scanner;

/**
 *
 * @author ASUS
 */
public class MyJosephus2 {
    public static void main(String[] args){
        long num=1,target=1;
        long quotient = 0;
        long loops = 0;
        
        System.out.println(Long.MAX_VALUE);
        Scanner s = new Scanner(System.in);
        System.out.println("请输入排队人数");
        long n = s.nextLong();
        
        while(num<n){
            num++;
            loops++;
            if(num-3>=target){
                quotient = (num-3-target)/3;
                if((num+quotient)<=n&&(num+quotient)>0){
                    num = num + quotient;
                    target = target + 3*(quotient+1);
                }
                else{
                    target = target + 3*(n-num+1);
                    num = n;
                }
            }
            else
                target = target + 3 - num;
        }
        System.out.println("经过 "+loops+" 次循环");
        System.out.println("第 "+target+"位的人留下");
    }

原理：比代码1稍微复杂了点，但如果理解了第一个，这个也不难。我们在完成代码1的推演时，发现target值每次向后移动3，这样很多时侯，我们可以预测target的位置，即我们可以一次走多步。代码  quotient = (num-3-target)/3; 就是在计算可以预测的步数，代码 num = num + quotient; 会大大减少循环次数，是缩减运算规模的关键，尤其是num-3-target这个值很大时。 代码 target = target + 3*(quotient+1); 就是经过quotient步后的target值。还有当 num+quotient > n 时，说明终点已在我们预测范围内，所以代码 target = target + 3*(n-num+1); 直接得到结果，并且num = n; 结束循环。注意这个(num+quotient)>0判断项，是防止num+quotient越过long的上界，在JAVA中不会抛异常，而是溢出为负数。

   可以挑战一下long的上限值了，大家自己试一下：

请输入排队人数
9223372036854775807
经过 2238 次循环
第 2314713631289671931位的人留下

只经过2238次循环，缩减的规模让人吃惊，当然是秒出结果。

好了，这部分就结束了，后续有时间再讨论一下，当3成为变值k时的情况。