约瑟夫环问题

一、约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3…n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。通常解决这类问题时我们把编号从0~n-1，最后结果+1即为原问题的解。

数组方式

假设下标从0开始，0，1，2 .. m-1共m个人，从1开始报数，报到k则此人从环出退出，问最后剩下的一个人的编号是多少？

现在假设m=10 
0 1 2 3 4 5 6 7 8 9 k=3 
第一个人出列后的序列为： 
0 1 3 4 5 6 7 8 9 
即: 
3 4 5 6 7 8 9 0 1（*） 
我们把该式转化为: 
0 1 2 3 4 5 6 7 8 (**) 
则你会发现: （(**)+3）%10则转化为(*)式了

也就是说，我们求出9个人中第9次出环的编号，最后进行上面的转换就能得到10个人第10次出环的编号了 
设f(m,k,i)为m个人的环，报数为k，第i个人出环的编号，则f(10,3,10)是我们要的结果 
当i=1时， f(m, k ,i) = (m+k-1) % m 
当i!=1时， f(m, k, i)= ( f(m-1, k, i-1)+k ) % m

#include<iostream>
using namespace std;

int fun(int m, int k, int i);
int main()
{
	for(int i = 1; i<= 10; i++)
	{
		cout << fun(10, 3, i) << " ";//以0开始编号的弹出顺序，以1的再加1
	}

	return 0;
}
int fun(int m, int k, int i)
{
	if(i == 1)
		return (m + k -1) % m;//不能用k-1，当k比m大的话就出错；
	else
		return (fun(m-1, k, i-1) + k ) % m;//每次都会少一个数，知道总人数为1的时候一直是他
}

输出：2 5 8 1 6 0 7 4 9 3;即第4个人最后弹出；

=======================================================================

用链表的方法直接循环

#include <iostream>
using namespace std;


class ListNode
{
public:
	int val;
	ListNode *next;
	ListNode(int x):val(x),next(NULL) {}
};

class Josephus
{
public:
	Josephus(int x)//建x个长度的环
	{
		n = x;
		head = new ListNode(1);
		ListNode * pre = head;
		ListNode * cur;

		for(int i=2; i <= x; i++)
		{
			cur = new ListNode(i);
			pre -> next = cur;
			pre = cur;
		}

		cur -> next = head;//串成环
	}

	void performKilling(int d)//淘汰赛
	{
		d %= n;//第一轮淘汰第(d % n)个人
		int count = 1;
		ListNode *pre;
		ListNode *cur = head;
		
		while(count++ <= n)//while(cur->next != cur)
		{
			for(int i = 1; i < d; i++)
			{
				pre = cur;//是否可以不要呢？不能，保存下来为了最后一行当前节点从下一个开始数。
				cur = cur -> next;
			}//遍历到要删除的d位置，使cur指向d位置
			
			cout << cur->val << " ";

			pre->next = cur->next;
			delete cur;
			cur = pre->next;//从下一个人继续数

		}
	}

private:
	ListNode *head;
	int n;//环的总长
};

int main()
{
	Josephus *J = new Josephus(10);
	J->performKilling(3);

}

二、约瑟夫环问题变种：

输入一个由随机数组成的数列（数列中每个数均是大于0的整数，长度已知），和初始计数值m。从数列首位置开始计数，计数到m后，将数列该位置数值替换计数值m，并将数列该位置数值出列，然后从下一位置从新开始计数，直到数列所有数值出列为止。如果计数到达数列尾段，则返回数列首位置继续计数。请编程实现上述计数过程，同时输出数值出列的顺序

比如： 输入的随机数列为：3,1,2,4，初始计数值m=7，从数列首位置开始计数（数值3所在位置）
第一轮计数出列数字为2，计数值更新m=2，出列后数列为3,1,4，从数值4所在位置从新开始计数
第二轮计数出列数字为3，计数值更新m=3，出列后数列为1,4，从数值1所在位置开始计数
第三轮计数出列数字为1，计数值更新m=1，出列后数列为4，从数值4所在位置开始计数
最后一轮计数出列数字为4，计数过程完成。
输出数值出列顺序为：2,3,1,4。

• 要求实现函数： 
void array_iterate(int len, int input_array[], int m, int output_array[])
【输入】 int len：输入数列的长度；
int intput_array[]：输入的初始数列
int m：初始计数值，步长
【输出】 int output_array[]：输出的数值出列顺序
【返回】 无

• 示例 
输入：int input_array[] = {3,1,2,4}，int len = 4， m=7
输出：output_array[] = {2,3,1,4}

#include <iostream>
using namespace std;

int array_iterate(int len, int input_array[], int m, int output_array[]);
int main()
{
	int a[] = {3,1,2,4};
	int b[4];
	memset(b,0,4*sizeof(int));//将数组b全部初始化为0
	array_iterate(4, a, 7, b);
	for(int i=0; i < 4; i++)
		cout << b[i] <<endl;
}

struct Node
{
	int data;
	Node *next;
};

int array_iterate(int len, int input_array[], int m, int output_array[])
{
	if(NULL == input_array || 0 ==m || 0 == len)
		return 0;
	//建环
	Node *node = new Node;
	Node *head = new Node;
	head->data = input_array[0];
	Node *p = head;
	int k=0;
	for(int i=1; i<len; i++)
	{
		node = new Node;
		node->data = input_array[i];
		p->next = node;
		p = node;
	}
	p->next = head;
	//建环完成
	//开始pk
	p = head;
	Node *q = new Node;
	int count;
	while(p->next != p)
	{
		count = 1;
		while (count < m)
		{
			q = p;
			p = p->next;
			count++;
		}
		m = p->data;
		output_array[k++] = m;
		
		q->next = p->next;
		p = q->next;
	}
	output_array[k] = p->data;//最后一个数
	return 1;
}

或者可以用数组的方式解决，其核心思想是：

chooseIndex = (startIndex + (m - 1) % len) % len;

即要删除的那个是从起始位置开始(包含)步长为m的那个元素，但是当步长大于总长时会重复遍历多次，总长的总倍数是可以直接跳过的，第一个对len求余是决定从开始跳多少步，第二个对len求余是决定是下标为数组的哪一个元素。

void array_iterate(int len, int input_array[], int m, int output_array[])
 {
      int startIndex = 0; // 下一次开始计数的下标
      int chooseIndex = 0; // 选中的下标
      int outputIndex = 0; // 输出数组的下标
      while(len > 0)
      {    
          startIndex = chooseIndex;
          chooseIndex = (startIndex + (m - 1) % len) % len;
          m = input_array[chooseIndex];
          output_array[outputIndex++] = m;
          // 数组左移
          for(int i = chooseIndex; i <= len - 2; ++i)
          {
              input_array[i] = input_array[i + 1];
          }
          -- len;
      }
 }