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

            继续讨论之前，先贴一段代码，对上一篇文章：约瑟夫环问题---秒级挑战长整极限（java）（一）

    中的代码做了简单优化：

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)/2;
                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+"位的人留下");
    }
}

很简单,  将原来quotient = (num-3-target)/3;  改为 ：quotient = (num-3-target)/2;

原理就是，我们在预测target的位置时，原来使用  quotient = (num-3-target)/3; 后续我们 会使用num = num + quotient;来缩减运算规模，那么我们又可以再预测quotient/3步。。。。这其实是一个赛跑问题，target和num的速度差是2，因此对2求商。

原算法运算结果：

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

优化后算法运算结果：

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

运算规模降低到10%。

下面开始讨论，当3成为变值k时的情况。其实大部分代码是可以继续使用，仅仅将3更改为k。先贴代码：

import java.util.Scanner;

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

需要注意的是，当k值较大时，而num值较小时，最初的递推运算是需要对num值求余的，因此增加了这段代码

if(num<k){
                tmp = k%num+target;
                if(tmp<=num)
                    target = tmp;
                else
                    target = tmp-num;
            }

来处理当num小于k时的情况。相信大家如果一直跟下来，会很好理解。运算结果：

请输入排队人数
9223372036854775807
请输入k值
1234567
经过 73947804 次循环
第 2394751183931662808位的人留下

到这个级别还是秒出结果的，当k值再大，就不行了。道理很简单，这个商 quotient = (num-k-target)/(k-1)  就是我们能够缩减的运算规模，而随着k值的增加，这个商数会大大减少，因此运算规模的缩减越来越不明显。