有10人围成圈数数,每次数到3的人退出其他人继续,问最后剩下的一个人原来的位置是多少

原文:http://blog.csdn.net/qq_24696917/article/details/52198603

这个问题是一个典型的约瑟夫环问题,对于这类题目我做了一些总结,下面我就分别用:数组、ArrayList、LinkedList、以及通项公式去解决。 
首先用数组:把人都按顺序放到数组中,每次叫到三的人改变其的值为-1,最后剩下的那个就是编号。

public class Test01 {
    public static void main(String[] args) {
        int n = 10;//参与游戏的人数
        //将数字放入数组
        int [] persons=new int[n];
        for(int i=1;i<persons.length;i++){
            persons[i-1]=i;

        }
        int saveCount=0;//目前数组中还存在的人数
        int index=0;//我们要进行报的数
        while(true){
            //移除人出局

            saveCount=0;//记录目前存活的人数每次循环都被初始化
            for(int i= 0;i<persons.length;i++){
                if(persons[i]!=-1){

                    index++;
                    if(index==3){
                        index=0;
            //当计数器等于3的时候改变计数器的值并且把当前人的值改为-1
                        persons[i]=-1;
                    }
                }
                //如果数组中的值不为-1存活人数+1
                if(persons[i]!=-1){
                    saveCount++;
                }
            }
            //如果存活的人只剩下一个,退出循环
            if(saveCount==1){
                break;
            }
        }
        System.out.println(Arrays.toString(persons));
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

用数组的方式进行求解是我们思考最少的,其原理就是,我们把初始的编号放到数组中,每次找到要移出的人的时候把这个值改变为-1,直至数组中只有一个不是-1,结束循环。但是这种方法每次循环都要循环整个数组,那我们可不可以每次循环后移出出局的人呢?答案是肯定的,java为我们提供了很多容器,容器都带有这种功能,下面我们就分别用ArrayList于LinkedList来解决。 
ArrayList:

public class Test02 {

    public static void main(String[] args) {
        //这里我用了字母初始化数组,为了更明显的表示
        List<String> list = new ArrayList<String>();
        for(char i = 'A'; i <= 'A' + 9; i++){
            list.add(Character.toString(i));
        }

        int n = 1;//计数器,因为每次都要移除一个人,所以n = 1
        while(list.size() > 1){
            for(int i = 0; i < list.size(); i++){
                if(n == 3){
                    list.set(i, "");//找到叫到三的人把它的值变为空
                    n = 1;
                }else{
                    n++;
                }   
            }
            for(int i = list.size() - 1; i >= 0; i--){
            //每次循环完成之后,统一移除元素,不然会报错
                if(list.get(i).length() == 0){
                    list.remove(i);
                }
            }
        }
        System.out.println(list.toString());
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

上面这个ArrayList有一点小瑕疵,因为我们不能每次找到人后就移除此人,而是要找到后先改变它的值,让它为空,然后再每次循环完成后统一移除,那有的人就该问了:那与用数组有什么差别,都是改变元素的值,只不过数组进行判断,ArrayList进行移除。 
事实的确如此,虽然用ArrayList每次循环后都移除了一些元素,下次循环的时候不用循环10次,但还不是我们想要的。所以我们在对这个代码进行改进,如下:

public class Test03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for(char i = 'A'; i < 'A' + 10; i++){
            list.add(Character.toString(i));
        }
        /*
         * 思路:
         *  1、得到每一次队列中,最后一个人应该报数的值:int n = list.size % 3
         *  2、每次找到元素移除后,把计数器的值+1,等于跳过一个人,因为找到人是叫到3的人退出,所以刚移除过的人旁边的人肯定不会移除
         */
        int a = 0;
        System.out.println(list.toString());
        while(list.size() > 1){
            for(int i = 0; i < list.size(); i++){
                a++;//2
                if(a == 3){
                    if(i == list.size() - 1){
                        a = 0;
                    }else{
                        a = 1;
                    }
                    list.remove(i);
                }
            }
            System.out.println(list.toString());
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

这种方法可能刚开始没有那么好理解,但是在第二个方法的基础下应该很快能够理解。 
下面就是用LinkedList来解决:

public class Monkey {

    public static void main(String[] args) {
        int number = 0;//计数器
        int count = 10;//玩家的总数

        LinkedList<Integer> monkeys = new LinkedList<>();
        for(int i = 1; i <= count; i++){
            monkeys.add(i);
        }

        //这里用了迭代器,每次取出数组中的下个元素
        Iterator<Integer> it = monkeys.iterator();
        while(count > 1){
        //每次进行迭代,如果有下个元素,计数器+1
            if(it.hasNext()){
                it.next();
                ++number;
            }else{
            //如果没有下个元素,迭代器从新赋值,即从头开始
                it = monkeys.iterator();
            }
            //如果找到元素,把计数器归零,移除元素,总数-1
            if(number == 3){
                number = 0;
                it.remove();
                count--;
            }
        }
        System.out.println("编号为:" + monkeys.element());
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

LinkedList与ArrayList方法类似,都是找到元素并且移除,都是计数器进行计数每次记录循环结果,当做下次循环开始的计数。

最后介绍一种比较难理解的方法,一种通项公式,因为这是约瑟夫环问题,如果我门改变人数,多往下写,就会找到规律,用高中学到的求解通项公式的方法,可以找到这道题的通项公式 : f(n) = (f(n-1) + k) % n f(1) = 0; 
n代表人数,k代表叫到的数字(本题中:n = 10, k = 3); 
实现代码如下:

public class Test04 {

    public static void main(String[] args){

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入参与游戏的人数:");
        int number = sc.nextInt();
        System.out.println("请输入数到几的人退出游戏");
        int k = sc.nextInt();
        //通项公式   f(n) = (f(n-1) + k) % n
        int last = 0; // f(1) = 0
        for(int i = k-1; i <= number; ++i){
            last = (last + k) % i;
        }
        System.out.println(last + 1);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

使用通项公式很简洁的就解决了此类问题,看起来也简单,但是这一种方法却是最难理解的,因为我们需要自己去找通项公式。当然如果你的脑容量够大,你也可以记下来。

四种方法各有优劣,选择你最能理解的去使用,尝试找到别的方法。 
计算机中的问题不可能只有一种解决方式。

没有更多推荐了,返回首页