剑指Offer面试题45：圆圈中最后剩下的数字

题目：圆圈中最后剩下的数字

        0,1,2,3,4……n这n个数字排列成一个圆圈，从数字0开始每次从这个圆圈里删除第m个数字。求出这个圆圈最后剩下的一个数字。

算法分析：

本题是有名的约瑟夫（josephuse）环问题。  例如，0,1,2,3,4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是：2,0,4,1，因此最后剩下的元素是数字3.

 

算法1：

可以采用环的链表来模拟圆圈。我们可以创建一个总共有n个节点的环形链表，然后每次在这个链表中删除第m个节点。

        while(list.size() > 1){                //循环直至只剩最后一个元素

            for(int i = 1; i < m; i++){

                index = (index + 1)%list.size();

            }

            list.remove(index);

        return list.get(0);  

算法2：查找数字规律，利用数学公式解决

首先我们定义一个关于n 和m 的方程町矶时，表示每次在n 个数字0,1, … , n-1中每次删除第m 个数字最后剩下的数字。

　　在这n个数字中， 第一个被删除的数字是(m-1)%n. 为了简单起见，我们把(m- 1)%n 记为k，那么删除k之后剩下的n-1个数字为0, 1, … , k-1，k+1, … , n-1，并且下一次删除从数字k+1开始计数。相当于在剩下的序列中， k+1排在最前面，从而形成k+1, .. . , n- 1, 0, I, … , k-1 。该序列最后剩下的数字也应该是关于n 和m 的函数。由于这个序列的规律和前面最初的序列不一样（最初的序列是从0 开始的连续序列），因此该函数不同于前面的函数，记为f’(n-1,m)。最初序列最后剩下的数字f(n, m）一定是删除一个数字之后的序列最后剩下的数字，即f(n, m)=f’(n-1, m）。

　　接下来我们把剩下的这n-1个数字的序列k-1， …, n-1, 0, 1, … , k-1做一个映射，映射的结果是形成一个从0 到n-2的序列：

k+1        ------>     0

k+2      --------->    1

……

n-1      -----    > n-k-2

0         ------->    n-k-1

1       --------->    n-k

.....

k-1   --------->    n-k

我们把映射定义为p，则p(x) = (x-k-1)%n。它表示如果映射前的数字是x,那么映射后的数字是（x-k-1)%n.该映射的逆映射是p-1(x)= (x+k+1)%n.

由于映射之后的序列和最初的序列具有同样的形式，即都是从0开始的连续序列，因此仍然可以用函数f来表示，记为f(n-1,m).根据我们的映射规则，映射之前的序列中最后剩下的数字f'(n-1,m) = p-1[(n-1,m)] = [f(n-1,m)+k+1]%n ,把k= (m-1)%n代入f(n,m) = f'(n-1,m) =[f(n-1,m)+m]%n.

经过上面的复杂的分析，我们终于找到一个递归的公示。要得到n个数字的序列中最后剩下的数字，只需要得到n-1个数字的序列和最后剩下的数字，并以此类推。当n-1时，也就是序列中开始只有一个数字0，那么很显然最后剩下的数字就是0.我们把这种关系表示为：

 

public int LastFunction2(int n, int m){

        if(n < 1 || m < 1)

            return -1;

        int last = 0;

        for(int i = 2; i <= n; i++)

            last = (last + m)%i;

        return last;

    }  

算法源程序：

/**************************************************************      
* Copyright (c) 2016, 
* All rights reserved.                   
* 版 本 号：v1.0                   
* 题目描述：圆圈中最后剩下的数字
* 			 0,1,2,3,4……n这n个数字排列成一个圆圈，从数字0开始每次从这个圆圈里删除第m个数字。求出这个圆圈最后剩下的一个数字。
* 输入描述：算法1输入一个数字数组，算法2计算的是0-4的5个数字，不用输入
* 程序输出： 请任意输入一个数组(以空格隔开)：
*			0 1 2 3 4
*			请输入每次删除的位置m:   3
*			算法1：最后剩下的元素是：3
*			算法2：n个数字最后剩下的元素是：3
*			算法2递归方法实现：3
* 问题分析： 无
* 算法描述： 算法1：可以采用环的链表来模拟圆圈。我们可以创建一个总共有n个节点的环形链表，然后每次在这个链表中删除第m个节点
* 			算法2：查找数字规律，利用数学公式解决
* 			f(n,m) =   0 				n = 1;
* 				   	   [f(n-1,m)+m]%n	n > 1;
* 完成日期：2016-10-09
***************************************************************/
package org.marsguo.offerproject45;

import java.util.*;

class SolutionMethod1{
	public int LastRemainFunction(int[] number, int m){
		if(number.length < 0 || m < 1)
			return -1;
		
		/*ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦
		LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引  但是缺点就是查找非常麻烦 要丛第一个索引开始*/
		List<Integer> list = new LinkedList<Integer>();
		for(int j = 0; j < number.length; j++){
			list.add(number[j]);
		}
		
		int index = 0;			//要删除元素的位置
		//int start = 0;
		
		while(list.size() > 1){				//循环直至只剩最后一个元素
			for(int i = 1; i < m; i++){
				index = (index + 1)%list.size();
			}
			list.remove(index);
			
//			if(index == list.size()){
//				index = 0;
//			}
		}
		
		return list.get(0);
	}
}

class SolutionMethod2{
	/*
	用循环方法实现：
	*/
	public int LastFunction2(int n, int m){
		if(n < 1 || m < 1)
			return -1;
		int last = 0;
		for(int i = 2; i <= n; i++)
			last = (last + m)%i;
		return last;
	}
	/*
	用递归方法实现
	*/
	public int LastFunction3(int n,int m){
		if(n < 1 || m < 1)
			return -1;
		else 
			return(LastFunction3(n-1,m)+m)%n;
	}
}

public class LastRemainingNumber {
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		System.out.println("请任意输入一个数组(以空格隔开)：");
		String str = scanner.nextLine();
		System.out.println("请输入每次删除的位置m:");
		int m = scanner.nextInt();
		String[] temp = str.split(" ");
		scanner.close();
		int[] array = new int[temp.length];
		for(int i = 0;i < temp.length;i++)
		{
			array[i] = Integer.parseInt(temp[i]);
		}
		
		SolutionMethod1 solution1 = new SolutionMethod1();
		int lastnumber1 = solution1.LastRemainFunction(array, m);
		System.out.println("算法1：最后剩下的元素是：" + lastnumber1); 
		
		SolutionMethod2 solution2 = new SolutionMethod2();
		int lastnumber2 = solution2.LastFunction2(5, m);
		System.out.println("算法2：n个数字最后剩下的元素是：" + lastnumber2);
		int lastnumber3 = solution2.LastFunction3(5, m);
		System.out.println("算法2递归方法实现：" + lastnumber3);
	}
}

程序运行结果：