约瑟夫环问题

一、约瑟夫环(约瑟夫问题)是一个数学的应用问题:已知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;
      }
 }


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值