约瑟夫问题

     约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。
从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；
依此规律重复下去，直到圆桌周围的人全部出列。

 

     1、最笨的解法就是按照算法要求，一步一步循环求解： 

import java.util.List;
import java.util.ArrayList;

public class YueSeFu {
	public static void main(String[] args){
		int n = 6; //人数
		int k = 1;//起始报数的人
		int m = 1; //报到13号的人出列
		List pList = createPersonList(n,k);
		for(int i=1;i<=m*n;i++){
			int len = pList.size();
			if(k > len && i==1){
				println("初始报数的人序号大于人数！");
			}
			if(m<=pList.size()){
				println(pList.get(m-1));
				pList = reCreateList(pList,m-1);
			}else{
				println(pList.get(m%pList.size()-1));
				pList = reCreateList(pList,m%pList.size()-1);
			}
			if(pList.size() == 1){
				break;
			}
		}
		println(pList.get(0));
	}
	/**
	 * 重新构建列表
	 * @param list
	 * @param index
	 * @return
	 */
	public static List reCreateList(List list, int index){
		List newList = new ArrayList();
		for(int i=index+1;i<list.size();i++){
			newList.add(list.get(i));
		}
		for(int j=0;j<index;j++){
			newList.add(list.get(j));
		}
		return newList;
	}
	/**
	 * 创建人员列表
	 * @param num
	 * @return
	 */
	public static List createPersonList(int num,int k){
		List list = new ArrayList();
		for(int i=0; i<num;i++){
			if(i+k > num){
				list.add(i+k-num);
			}else{
				list.add(i+k);
			}
//			println(list.get(i));
		}
		return list;
	}
	public static void println(Object b){
		System.out.println(b);
	}
}

 

   2、效率更高的递归解法：

  

public class Yuesefu001 {

	/**
	 * 约瑟夫环是一个数学的应用问题：
	 * 
	 * *已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。 *从编号为k的人开始报数，数到m的那个人出列；
	 * *他的下一个人又从1开始报数，数到m的那个人又出列； *依此规律重复下去，直到圆桌周围的人全部出列。
	 * 
	 * @param args
	 */
	private static StringBuffer removedStr = new StringBuffer("");// 记录删除的数字

	public static void main(String[] args) {
		long startTime = System.currentTimeMillis(); // 获取开始时间
		process(100, 2, 9);
		System.out.println(removedStr.substring(0, removedStr.length() - 1));
		long endTime = System.currentTimeMillis(); // 获取结束时间
		System.out.println("程序运行时间： " + (endTime - startTime) + "ms");
	}

	public static void process(int n, int k, int m) {

		// 构建一个list，存放人数
		LinkedList<Integer> list = new LinkedList<Integer>();
		for (int i = 0; i < n; i++) {
			if(i + k > n ){
				list.add(i + k - n);
			}else{
				list.add(i + k);
			}
		}
		int count = 1;// 记录数的人数
		cycleCal(list, count, m);
	}

	public static void cycleCal(LinkedList<Integer> list, int count, int m) {

		int len = list.size();
		if (len > 1) {
			for (int i = 0; i < len; i++) {
				if (count == m) {// 第m个时，remove、
					removedStr.append(list.get(i)).append(",");
					list.remove(i);
					len = list.size();
					i--;
					count = 0;
				}
				count++;
			}
			cycleCal(list, count, m);
		} else {
			if (len != 0) {
				removedStr.append(list.get(0)).append(",");
			}
		}
	}
}

  

 3、摘的别人很好的一个数组解法：

  

/**
 * 2010-07-17 love_ai87 (中级程序员)
 约瑟夫问题涉及的是一个顺序表的读取问题。
 设有你n个人站成一圈，每个人按顺序编号（从1到n），
 从编号为1开始循环报数，数到m的就出列，如此重复开始，
 直到n个人都出列。
 约瑟夫问题是：对于任意给定的n个人的原始排列顺序和m值，求出n个人的出列顺序。 

 设有8个人，当m=4时的出列顺序为：4   8   5   2   1   3   7   6   。 
 */
public class TestYueSeFu {
	
	public static void main(String[] aregs) {
		int[] a = { 1, 2, 3, 4, 5, 6, 7, 8 };
		yy(a, 4);
	}

	//iteye 別人算法，需要紙來算 一下 ，求解
	static void yy(int[] a, int m) {
		int t = 0;
		int length = a.length;
		for (int i = length; i > 0; i--) {
			t = (t + m - 1) % i;
			System.out.print(a[t] + "   ");
			for (int j = t; j < i - 1; j++) {
				a[j] = a[j + 1];
			}
		}
	}
}