约瑟夫环问题
约瑟夫环问题(Josephus)
算法设计
Josephus jp=new Josephus(); int a[]=new int[n]; for(int i=0;i<n;i++){ a[i]=i+1; } jp.SortArray(a,n,m,k,g); } public void show(int[]b,int g){ for(int i=b.length-g;i<b.length;i++){ System.out.print(b[i]+" "); } }
• b[c]=a[i]; • a[i]=0; • c++; • if(c==n) break; • } • System.out.print(“最后出列的 3人: "); • this.show(b,g); • } • }
• 1.数据选择： 要求：n<2^15; 1<=k<=n; 2.数据和结果显示：
(3)当然其中还是会存在一些漏洞，需要进 一步的改进。在计算机中是容不得丝毫的 错误的，这也让我们学到了面对科学要持 有严谨的态度，否则必定得不到应该有的 结果。
总人数n 起始号码k 循环数m 最后出列的3人 总人数n 起始号码k 循环数m 最后出列的3人 总人数n 起始号码k 循环数m 最后出列的3人 48 6 15 47 21 46 105 73 4 87 32 21 300 80 12 70 296 198 总人数n 起始号码k 循环数m 68 34 25
输出格式：
T行最后min（n，3）个出列的编号。 结果：6 1 5
问题背景
• 这个问题是以弗拉维奥•约瑟夫斯命名的， 它是1世纪的一名犹太历史学家。他在自己 的日记中写道，他和他的40个战友被罗马 军队包围在洞中。他们讨论是自杀还是被 俘，最终决定自杀，并以抽签的方式决定 谁杀掉谁。约瑟夫斯和另外一个人是最后 两个留下的人。约瑟夫斯说服了那个人， 他们将向罗马军队投降，不再自杀。
实验报告 约瑟夫问题
pCur->next = pNew;
pCur = pNew;
printf("结点%d,密码%d\n",pCur->id, pCur->cipher);
}
}
printf("完成单向循环链表的创建!\n");
}
(3)运行"约瑟夫环"问题
static void StartJoseph(NodeType **, int)
exit(-1);
}
pNew->id = iId;
pNew->cipher = iCipher;
pNew->next = NULL;
return pNew;
}
(6)测试链表是否为空,空为TRUE，非空为FALSE
static unsigned EmptyList(const NodeType *pHead)
实验内容
利用循环链表实现约瑟夫环求解。
实验说明
1.问题描述
约瑟夫问题的：编号为1，2，....,N的N个人按顺时针方向围坐一圈,每人持有一个密码(正整数)，一开始任选一个正整数作为报数上限值M，从第一个人开始按顺时针方向自1开始顺序报数，报到M时停止报数。报M的人出列，将他的密码作为新的M值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序。
{
if(!pHead)
{
return TRUE;
}
return FALSE;
}
实验中遇到的问题及解决方法
实验结果如下：
实验总结（结果和心得体会）
细究“约瑟夫环”
细究“约瑟夫环”0 引言17世纪的法国数学家加斯帕在《数目的游戏问题》中讲了这样一个故事：15个教徒和15 个非教徒在深海上遇险，必须将一半的人投入海中，其余的人才能幸免于难，于是想了一个办法：30个人围成一圆圈，从第一个人开始依次报数，每数到第九个人就将他扔入大海，如此循环进行直到仅余15个人为止。
问怎样排法，才能使每次投入大海的都是非教徒。
1 问题描述有n个人围成一圈，顺序排号。
从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
示例一：输入：n = 3输出：“2”解释：首先轮流报数，3就被退出了，之后1,2,1,1就被退出了，最后只剩下了2。
2 算法描述解题思路：首先因为考虑到是不断的有规律退出数字则首先要考虑到循环的使用，我们从索引上看，如果将每次循环的三人看成一组，则被退出的人的索引为2，此时我们就知道了我们删去的就应该是索引为2的人。
但我们此时又想到该如何让其满足我们想得到的方式呢？我们不妨将其横排排列，123删去3后变成1212，此时我们发现可以将之前还未删去的数值排列在其之后，我们可以多举几个例子如1234变成12412。
那么此时我们就解决了第一个如何将其围成圈的问题，而之后就到了最关键的时候了，如何删去这些值？我们又举123为例，若想得到1，我们可以有很多的做法，而取余则是一种很巧的运算方式，如：“1”的位置是1，所以0%3（3是这三个值的长度（1,2,3））得到0，而1 的索引就是0，同理我们可得其他的值。
根据规律可得，若k=2的值为删去的数，那么我们只需进行k = k+2得到下一个删去的值。
（简单讲就是本事索引除以长度得到自身位置，本身长度加1除以长度得到下一个位置，同理加2）3 实验结果与讨论通过编程最终求出了约瑟夫环的问题。
附件代码清单用python求出杨辉三角数4 结语约瑟夫环是一个很经典的数学问题，其中的解法多种多样，通过这种复杂的循环可以使我们很轻松的解决一些问题。
约当产量法经典例题
约当产量法经典例题
约瑟夫产量法（JosephusProblem）是一个著名的算法问题，它可以帮助我们解决许多问题，例如，从一个特定的旋转序列中确定最优排列顺序。
因此，它也被称为约瑟夫环，用于描述在一定环境下的最优策略。
“约瑟夫问题”是表示从一组项中抽取某一项的问题，其中某些项的顺序有些特殊的限制，例如，有一组人坐在一个圆圈中，按顺时针方向排序，从某一位置开始，每次从这个圆圈中抽取第三个人。
此外，还有一些特殊情况，可以使用约瑟夫产量法来解决。
例如： 1.一组数据分成两组，并按顺序排列，使每组的最后一个元素相同（最优排列）。
2.定N个数，问如何取每组K个数，使每组的和最大。
3.一组数据按照某一特殊序列排列，使得数据的总和最小。
例如，有五个人在一个圆圈中排成一圈，从A开始，若按照约瑟夫产量法，以步长2取数，则抽取的顺序为：A、C、E、B、D。
另外，约瑟夫产量法还可以应用于路径搜索问题，如有一组城市，想要找到最短路径，即从某一城市出发经过每个城市朝着某一方向，同时最小化旅行总路程，则可以使用约瑟夫产量法计算。
此外，约瑟夫产量法还可以应用于多种拓扑排序问题，例如：求解从具有某一特定拓扑结构的有向图中取出特定元素的最佳排序问题。
总之，约瑟夫产量法是一种有效的、被广泛应用的算法，适用于
解决许多问题，如组成、拓扑排序和数据搜索等等。
因此，它被称为一种经典算法，是学习算法的一个重要基础。
约瑟夫环问题小结
约瑟夫环问题⼩结⼀问题描述约瑟夫环问题的基本描述如下：已知n个⼈(以编号1，2，3...n分别表⽰)围坐在⼀张圆桌周围。
从编号为1的⼈开始报数，数到m的那个⼈出列；他的下⼀个⼈⼜从1开始报数，数到m的那个⼈⼜出列；依此规律重复下去，要求找到最后⼀个出列的⼈或者模拟这个过程。
⼆问题解法在解决这个问题之前，⾸先我们对⼈物进⾏虚拟编号，即相当于从0开始把⼈物重新进⾏编号，即⽤0,1,2,3,...n-1来表⽰⼈物的编号，最后返回的编号结果加上1，就是原问题的解(为什么这么做呢，下⽂有解释)。
⽽关于该问题的解通常有两种⽅法：1.利⽤循环链表或者数组来模拟整个过程。
具体来讲，整个过程很明显就可以看成是⼀个循环链表删除节点的问题。
当然，我们也可以⽤数组来代替循环链表来模拟整个计数以及出列的过程。
此处只给出利⽤数组来模拟这个过程的解法，最终结果为最后⼀个出列的⼈的编号：#include<iostream>#include<unordered_map>#include<queue>#include<cstring>#include<cstdlib>#include<cmath>#include<algorithm>#include<sstream>#include<set>#include<map>using namespace std;int main(){int n,m;cin>>n>>m;vector<int>rs(n);for(int i = 0 ; i < n; i++)rs[i] = i + 1;//对⼈物重新进⾏编号，从0开始int cur_index = 0;//当前圆桌状态下的出列⼈的编号int out_cnt = 0;//⽤以表⽰出列的⼈数int cnt = n;//表⽰当前圆桌的总⼈数while(out_cnt < n - 1)//当out_cnt等于n-1时，循环结束，此时圆桌师⽣最后⼀个⼈，即我们要的结果{if(cur_index + m > cnt){if((cur_index + m) % cnt == 0)//这种情况需要单独考虑，否则cur_index就变成负值了cur_index = cnt - 1;elsecur_index = (cur_index + m) % cnt - 1;}elsecur_index = cur_index + m - 1;cnt--;out_cnt++;cout<<"当前出列的为："<<*(rs.begin() + cur_index)<<endl;rs.erase(rs.begin() + cur_index);//从数组中删去需要出队的⼈员}cout<<"最后⼀个出列的⼈物为："<<rs[0]<<endl;}该⽅法的时间复杂度为O(nm)，空间复杂度为O(n)，整个算法的基本流程还是⽐较清晰的，相当于每次循环更新cur_cnt、cnt和out_cnt这三个变量，当out_cnt == n-1时，此时出队的⼈数⼀共有n-1⼈，圆桌上只剩下⼀个⼈了，停⽌循环。
约瑟夫环问题详解
约瑟夫环问题详解很久以前，有个叫Josephus的⽼头脑袋被门挤了，提出了这样⼀个奇葩的问题：已知n个⼈（以编号1，2，3...n分别表⽰）围坐在⼀张圆桌周围。
从编号为k的⼈开始报数，数到m的那个⼈出列；他的下⼀个⼈⼜从1开始报数，数到m的那个⼈⼜出列；依此规律重复下去，直到圆桌周围的⼈全部出列这就是著名的约瑟夫环问题，这个问题曾经风靡⼀时，今天我们就来探讨⼀下这个问题。
这个算法并不难，都是纯模拟就能实现的。
思路⼀：⽤两个数组，mark[10000]和num[10000],mark这个数组⽤来标记是否出队，num这个⽤来存值，然后每次到循环节点的时候就判断mark是否为0(未出队)，为0则输出num[i]，并标记mark[i]=1，直到所有的num都出队。
附上C++代码：#include<iostream>#include<cstring>#include<cstdio>#include<cstdlib>#include<cctype>#include<cmath>#include<algorithm>using namespace std;char num[1000];bool mark[1000];int main(){while(true){memset(mark,0,sizeof(mark));int n;int k,m;int i,j;int del=k-1;cin>>n>>k>>m;for(i=0;i<n;++i){cin>>num[i];}int cnt=n;for(i=cnt;i>1;--i){for(int j=1;j<=m;){del=(del+1)%n;if(mark[del]==0)j++;}cout<<num[del]<<" ";mark[del]=1;}for(i=0;i<n;++i){if(mark[i]==0)break;}cout<<endl<<"The final winner is:"<<num[i]<<endl;}return 0;}思路⼆：⽤⼀个数组就可，每次到了循环节点了就将num[i]输出，然后将后⾯的值往前移动⼀位，直到所有的节点出列。
约瑟夫斯问题
约瑟夫斯问题约瑟夫问题维基百科，⾃由的百科全书跳到导航跳到搜索约瑟夫问题（有时也称为约瑟夫斯置换），是⼀个出现在计算机科学和数学中的问题。
在计算机编程的算法中，类似问题⼜称为约瑟夫环。
⼈们站在⼀个等待被处决的圈⼦⾥。
计数从圆圈中的指定点开始，并沿指定⽅向围绕圆圈进⾏。
在跳过指定数量的⼈之后，处刑下⼀个⼈。
对剩下的⼈重复该过程，从下⼀个⼈开始，朝同⼀⽅向跳过相同数量的⼈，直到只剩下⼀个⼈，并被释放。
问题即，给定⼈数、起点、⽅向和要跳过的数字，选择初始圆圈中的位置以避免被处决。
历史这个问题是以弗拉维奥·约瑟夫命名的，他是1世纪的⼀名犹太历史学家。
他在⾃⼰的⽇记中写道，他和他的40个战友被罗马军队包围在洞中。
他们讨论是⾃杀还是被俘，最终决定⾃杀，并以抽签的⽅式决定谁杀掉谁。
约瑟夫斯和另外⼀个⼈是最后两个留下的⼈。
约瑟夫斯说服了那个⼈，他们将向罗马军队投降，不再⾃杀。
约瑟夫斯把他的存活归因于运⽓或天意，他不知道是哪⼀个。
[1]解法⽐较简单的做法是⽤循环单链表模拟整个过程，时间复杂度是O(n*m)。
如果只是想求得最后剩下的⼈，则可以⽤数学推导的⽅式得出公式。
且先看看模拟过程的解法。
Python版本-- coding: utf-8 --class Node(object):def init(self, value):self.value = valueself.next = Nonedef create_linkList(n):head = Node(1)pre = headfor i in range(2, n+1):newNode = Node(i)pre.next= newNodepre = newNodepre.next = headreturn headn = 5 #总的个数m = 2 #数的数⽬if m == 1: #如果是1的话，特殊处理，直接输出print (n)else:head = create_linkList(n)pre = Nonecur = headwhile cur.next != cur: #终⽌条件是节点的下⼀个节点指向本⾝for i in range(m-1):pre = curcur = cur.nextprint (cur.value)pre.next = cur.nextcur.next = Nonecur = pre.nextprint (cur.value)using namespace std;typedef struct _LinkNode {int value;struct _LinkNode* next;} LinkNode, *LinkNodePtr;LinkNodePtr createCycle(int total) {int index = 1;LinkNodePtr head = NULL, curr = NULL, prev = NULL;head = (LinkNodePtr) malloc(sizeof(LinkNode));head->value = index;prev = head;while (--total > 0) {curr = (LinkNodePtr) malloc(sizeof(LinkNode));curr->value = ++index;prev->next = curr;prev = curr;}curr->next = head;return head;}void run(int total, int tag) {LinkNodePtr node = createCycle(total);LinkNodePtr prev = NULL;int start = 1;int index = start;while (node && node->next) {if (index == tag) {printf("%d\n", node->value);prev = node->next;node->next = NULL;node = prev;} else {prev->next = node->next;node->next = NULL;node = prev->next;}index = start;} else {prev = node;node = node->next;index++;}}}int main() {if (argc < 3) return -1;run(atoi(argv[1]), atoi(argv[2]));return 0;}数学推导解法我们将明确解出{\displaystyle k=2}k=2时的问题。
循环队列之约瑟夫环问题
循环队列之约瑟夫环问题约瑟夫问题 约瑟夫环（约瑟夫问题）是⼀个数学的应⽤问题：已知n个⼈（以编号1，2，3...n分别表⽰）围坐在⼀张圆桌周围。
从编号为k的⼈开始报数，数到m的那个⼈出列；他的下⼀个⼈⼜从1开始报数，数到m的那个⼈⼜出列；依此规律重复下去，直到圆桌周围的⼈全部出列。
通常解决这类问题时我们把编号从0~n-1，最后结果+1即为原问题的解。
循环队列求解（链式）#include<stdio.h>#include<stdlib.h>//循环队列//typedef int ElemType;typedef struct QueueNode{int data;struct QueueNode *next;}QueueNode;typedef struct Queue{QueueNode *front;QueueNode *rear;}Queue;void InitQueue(Queue *q){q->front=q->rear=NULL;}void EnQueue(Queue *q , int value){QueueNode *temp=(QueueNode*)malloc(sizeof(QueueNode));temp->data=value;if(q->rear==NULL){temp->next=temp;q->rear=q->front=temp;}else{temp->next=q->rear->next;q->rear->next=temp;q->rear=temp;}}//enter a element from the tailvoid DeQueue(Queue *q, int *value){QueueNode *temp=(QueueNode*)malloc(sizeof(QueueNode)); if(q->rear==NULL){return;}// It's nullelse if(q->rear->next==q->rear){*value=q->front->data;free(q->rear);q->rear=q->front=NULL;}//It just has one nodeelse{*value=q->front->data;temp=q->front;q->front=temp->next;q->rear->next=q->front;}//more one nodefree(temp);}//delete a element from the headint main(){Queue *q=(Queue*)malloc(sizeof(Queue));int i,m,n,count,temp;printf("请输⼊⼈数n和循环要报的数m（两数之间留个空格）\n"); scanf("%d%d",&n,&m);for(i=1;i<=n;i++)EnQueue(q,i);printf("出圈序列：\n");while(q->front){ count=1;while(count<m){q->front=q->front->next;q->rear=q->rear->next;count++;}count=1;DeQueue(q,&temp);printf("%d ",temp);}putchar('\n');}简单解法#include <stdio.h>int josephus(int n, int m) {if(n == 1) {return0;}else {return (josephus(n-1, m) + m) % n;}}int main() {int n, m;while (scanf("%d", &n) == 1) {if (!n) {break;}scanf("%d", &m);int result = josephus(n, m);printf("%d\n", result+1);}return0;}。
约瑟夫环问题的三种解法
约瑟夫环问题的三种解法约瑟夫问题是个著名的问题：N个⼈围成⼀圈，第⼀个⼈从1开始报数，报到k的⼈将被杀掉，接着下⼀个⼈⼜从1开始报，直到最后剩下⼀个，求最后留下的⼈的下标。
题⽬集合解法1：暴⼒可以直接暴⼒求解，时间复杂度为O(nk)解法2：递推设f(n,k)为当n个⼈围成⼀圈时，最后留下的⼈的下标。
对于f(n-1,k)来说，其结果相当于f(n,k)的结果向前移动k\%(n-1)位。
因为对于f(n,k)来说，去掉第⼀轮报的数(k\%n)后，现在就只剩下n-1个数，并且是以(k\%(n-1)+1)作为第⼀个数,即所有数向前移动k\%(n-1)位。
现在的结果就为f(n-1,k)对于f(5,3)来说,其结果为4。
当其去掉第⼀轮报的数后，其向前移动了(3\%4)位，以4为起始，f(4,3)结果为1，对应着f(5,3)的结果4向前移动了3位所以反过来看即为,即为f(n-1,k)的结果向后移动k\%(n-1)位即f(n+1,k)=(f(n,k)+k\%n)\%n (x下标从0开始,因为取模结果为[0,n-1])时间复杂度为O(n)ll josephus2(ll n,ll k){ll pos=0;for(int len=1;len<=n;len++){pos = (pos+k)%len;}return pos+1;}递推代码解法3：如果当前这⼀位⼈没被杀掉，则他可以放在幸存者的末尾，直到幸存者数量为1所以对于下标为i的⼈，如果在他前⾯已经被杀掉了q个⼈，那么他的新的下标为n+q(k-1)+x,(1\leq x <k)如下图所⽰，最后被淘汰的编号⼀定是n*k，所以幸存者最后的编号是n*k我们现在需要从幸存者最后的编号中恢复出最初编号假设幸存者这⼀次的编号为p os_{i}，在他后⾯包括他还有x位幸存者，则[pos_{i-1},pos_{i})间⼀定有x个不能被k整除的数这样才能使在他后⾯包括他还有x位幸存者。
约瑟夫环问题(Josephus)
• b[c]=a[i]; • a[i]=0; • c++; • if(c==n) break; • } • System.out.print(“最后出列的 3人: "); • this.show(b,g); • } • }
• 1.数据选择： 要求：n<2^15; 1<=k<=n; 2.数据和结果显示：
问题描述
• 已知n（<2^15）个人（以编号1,2，…，n 分别表示）围坐在一圆桌上，从编号为k （1≤ k≤ n）的人开始报数，数到m的那个 人出列，他的下一个人又从1开始报数，数 到m的那个人又出列，依此重复，直到圆桌 周围的人全部出列，依次输出最后个整数T（<2^15）表示测 试次数，接着第二到T+1行分别为n，m和k 的值。 例：2 10 2 3
• public void SortArray(int[]a,int n,int m,int k,int g){ • int[] b=new int[n]; • int c=0; • int i=k-2; • while(true){ • for(int j=0;j<m;){ • i=(i+1)%n; • if(a[i]!=0){ • j++; • } • }
总人数n 起始号码k 循环数m 最后出列的3人 总人数n 起始号码k 5 2 2 2 1 4 20 6
数据测试
总人数n 起始号码k 循环数m 最后出列的3人 总人数n 起始号码k 循环数m 最后出列的3人
10 2 3 6 1 5 30 4 7 18 23 26
循环数m
最后出列的3人
8
3 14 6
数据测试
最后出列的3人 总人数n
约瑟夫问题
约瑟夫问题约瑟夫问题约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。
例如N=6，M=5，被杀掉的人的序号为5，4，6，2，3。
最后剩下1号。
假定在圈子里前K个为好人，后K个为坏人，你的任务是确定这样的最少M，使得所有的坏人在第一个好人之前被杀掉。
举个例子：有64名战士被敌人俘虏了。
敌人命令他们拍成一圆圈，编上号码1，2，3…，64。
敌人把1号杀了，又把3号杀了，他们隔着一个杀一个这样转着圈杀。
最后只剩下一个人，这个人就是约瑟夫斯。
请问约瑟夫斯是多少号？（这就是“约瑟夫斯”问题。
）这个问题解答起来比较简单：敌人从1号开始，隔一个杀一个，第一圈把所有的奇数号码的战士圈杀光了。
剩下的32名战士需要重新编号，而敌人在第二圈杀死的是重新编号的奇数号码。
由于第一圈剩下的全部是偶数号2，4，6，…，64。
把它们全部用2去除，得1，2，3，…，32。
这是第二圈编的号码。
第二圈杀过以后，又把奇数号码都杀掉了，还剩16个人。
如此下去，可以想到最后剩下的必然是64号。
$64=2^6$，它可以连续被2整除6次，是从1到64中能被2整除次数最多的数，因此，最后必然把64 号留下。
如果有65名战士被俘，敌人还是按上述的方法残杀战士，最后还会剩下约瑟夫斯吗？经过计算，很容易得到结论，不是。
因为第一个人被杀后，也就是1号被杀后，第二个被杀的是必然3号。
如果把1号排除在外，那么还剩下的仍是64人，新1号就是3号。
这样原来的2号就变成了新的64 号，所以剩下的必然是2号。
进一步的归类，不难发现如果原来有$2^k$个人，最后剩下的必然$2^k$号；如果原来有$2^k+1$个人，最后剩下2号；如果原来有$2^k+2$个人，最后剩下4号……如果原来有$2^k+m$个人，最后剩下2m号.比如：原来有100人，由于$100=64+36=2^6+36$，所以最后剩下的就是36×2=72号；又如：原来有11 1人，由于$100=64+47=2^6+47$，所以最后剩下的就是47×2=94号传说古代有一批人被蛮族俘虏了，敌人命令他们排成圆圈，编上号码1，2，3，…然后把1号杀了，把3号杀了，总之每隔一个人杀一个人，最后剩下一个人，这个人就是约瑟夫斯。
约 瑟 夫 环 问 题 的 三 种 解 法
约瑟夫问题(数学解法及数组模拟)约瑟夫问题（有时也称为约瑟夫斯置换，是一个出现在计算机科学和数学中的问题。
在计算机编程的算法中，类似问题又称为约瑟夫环。
又称“丢手绢问题”.）据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。
然而Josephus 和他的朋友并不想遵从。
首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。
接着，再越过k-1个人，并杀掉第k个人。
这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。
问题是，给定了和，一开始要站在什么地方才能避免被处决？Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。
? 以上来自百度百科约瑟夫问题是个很有名的问题：N个人围成一个圈，从第一个人开始报数，第M个人会被杀掉，最后一个人则为幸存者，其余人都将被杀掉。
例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3，1。
约瑟夫问题其实并不难，但求解的方法多种多样；题目的变化形式也很多。
接下来我们来对约瑟夫问题进行讨论。
1.模拟解法优点 : 思维简单。
?缺点：时间复杂度高达O(m*n)当n和m的值较大时，无法短时间内得到答案。
为了叙述的方便我们将n个人编号为：1- n ，用一个数组vis 来标记是否存活：1表示死亡 0表示存活 s代表当前死亡的人数? cnt 代表当前报了数的人数用t来枚举每一个位置(当tn时 t=1将人首尾相连)? 那么我们不难得出核心代码如下：bool vis[1000]; --标记当前位置的人的存活状态int t = 0; --模拟位置int s = 0; --死亡人数int cnt = 0; --计数器if(t n) t = 1;if(!vis[t]) cnt++; --如果这里有人,计数器+1if(cnt == m) --如果此时已经等于m,这这个人死去cnt = 0; --计数器清零s++; --死亡人数+1vis[t] = 1 --标记这个位置的人已经死去coutt" "; --输出这个位置的编号}while(s != n);接下来我们来看另一种更为高效快速的解法数学解法我们将这n个人按顺时针编号为0~n-1，则每次报数到m-1的人死去，剩下的人又继续从0开始报数，不断重复，求最后幸存的人最初的编号是多少？我们只需要将最后求得的解加1就能得到原来的编号。
约瑟夫环问题
约瑟夫环问题一、前言约瑟夫环（Josephus ）问题是由古罗马的史学家约瑟夫（Flavius Josephus ）提出的。
该问题的说法不一，传说他参加并记录了公元66—70年犹太人反抗罗马的起义。
约瑟夫作为一个将军，设法守住了裘达伯特城达47天之久，在城市沦陷之后，他和40名死硬的将士在附近的一个洞穴中避难。
在那里，这些叛乱者表决说“要投降毋宁死”。
于是，约瑟夫建议每隔两个人杀死一人，而这个顺序是由抽签决定的。
约瑟夫有预谋地抓到了最后一签，并且，作为洞穴中的两个幸存者之一，他说服了另一个幸存者一起投降了罗马。
假设现在一个房间内共有n 个人。
同上所述，“杀人狂” 只想留下一个人活命，并且他将按下面的规则去杀人：● 所有的人围成一圈；● 顺时针报数，每次报到q 的人将被杀掉； ● 被杀掉的人将从房间内移走；● 然后从被杀掉的下一个人重新报数，直到剩余一人。
你非常不幸地参加了这场“游戏”，当然，你是想活命的，所以你必须快速决定要站到哪一个位置，才能使得最后留下的人是你。
这就是最初的“约瑟夫环”问题，纯粹的数学计算无法做出解答，但对于参加信息学竞赛的选手来说，可以快速的编写一个程序来解决。
下面就针对这个问题进行分析并解答。
二、特例当q=2时，是约瑟夫环的一个特例，可以利用数学的方法快速求解。
分析：如果只有2个人，显然剩余的为1号。
如果有4个人，在第一轮移除掉2、4以后，只剩下1、3，现在环中又仅剩下2个人了，我们已经知道2个人时，结果为1，所以当n=4时，最后剩余的也为1号。
如此可设想：当()02≥=k n k时，最后剩余的必定为1。
我们定义()n J 为由n 个人的构建成的约瑟夫环最后的结果，则有()12=kJ 。
让我们来证明该设想的正确性：11222--=-=k k k n （第一轮后，移除掉122/2-=k k 个人，剩余12-k ，1号仍在环中） 221222---=-=k k k n （第二轮后，1号仍在环中）……112222=-=n （1号仍在序列当中）()12=J在上面的分析中，每一轮的移除操作，均移除一半出列，1号总在剩余的环中。
约瑟夫环问题（最简单的数学解法）
约瑟夫环问题（最简单的数学解法）基本问题描述：已知n个⼈（以编号1，2，3...n分别表⽰）围坐在⼀张圆桌周围。
从编号为1的⼈开始报数，数到m的那个⼈出列；他的下⼀个⼈⼜从1开始报数，数到m的那个⼈⼜出列；依此规律重复下去，直到圆桌周围的⼈全部出列。
（也类似于变态杀⼈狂问题）通常解决这类问题时我们把编号从0~n-1，最后结果+1即为原问题的解。
通常，我们会要求输出最后⼀位出列的⼈的序号。
那么这⾥主要研究的是最后⼀个出列的⼈的序号要怎么确定。
当n，m数据量很⼩的时候，我们可以⽤循环链表模拟约瑟夫环的过程。
当模拟到⼈数等于1的时候，输出剩下的⼈的序号即可。
这种⽅法往往实现起来⽐较简单，⽽且也很容易理解。
但是时间复杂度却是很糟糕的，达到了O（n m），这样的话，其实在n，m⽐较⼤的时候（n m达到10^8或者更⼤），那么要得出结果往往需要耗费很长的时间，但是我们可以运⽤⼀点数学上的技巧，将最后结果推导出来。
为了简化出列的过程：⾸先我们把这n个⼈的序号编号从0~n-1（理由很简单，由于m是可能⼤于n的，⽽当m⼤于等于n时，那么第⼀个出列的⼈编号是m%n，⽽m%n是可能等于0的，这样编号的话能够简化后续出列的过程），当数到m-1的那个⼈出列，因此我们编号完成之后，开始分析出列的过程：第⼀次出列：⼀开始的时候，所有⼈的编号排成序列的模式即为：0,1,2,3,4,5...n-2，n-1那么第⼀次出列的⼈的编号则是(m-1)%n1，那么在第⼀个⼈出列之后，从他的下⼀个⼈⼜开始从0开始报数，为了⽅便我们设k1 =m%n1（n1为当前序列的总⼈数）那么在第⼀个⼈出列之后，k1则是下⼀次新的编号序列的⾸位元素，那么我们得到的新的编号序列为：k1，k1+1，k1+2，k1+3...n-2，n-1，0，1，2...k1-3，k1-2 (k1-1第⼀次已出列)那么在这个新的序列中，第⼀个⼈依旧是从0开始报数，那么在这个新的序列中，每个⼈报的相应数字为：0,1，2,3....n-2那么第⼆次每个⼈报的相应数字与第⼀次时⾃⼰相应的编号对应起来的关系则为：0 --> k11 --> k1+12 --> k1+2...n-2 ---> (k1+n-2)%n1(n1为当前序列的总⼈数，因为是循环的序列，k1+n-1可能⼤于总⼈数)那么这时我们要解决的问题就是n-1个⼈的报数问题（即n-1阶约瑟夫环的问题）可能以上过程你还是觉得不太清晰，那么我们重复以上过程，继续推导剩余的n-1个⼈的约瑟夫环的问题：那么在这剩下的n-1个⼈中，我们也可以为了⽅便，将这n-1个⼈编号为：0,1,2,3,4...n-2那么此时出列的⼈的编号则是（m-1） % n2（n2为当前序列的总⼈数），同样的我们设k2 = m % n2，那么在这个⼈出列了以后，序列重排，重排后新的编号序列为：k2，k2+1，k2+2，k2+3...n-2，n-1，0，1，2...k2-3，k2-2 (k2-1第⼀次已出列)那么在这个新的序列中，第⼀个⼈依旧是从1开始报数，那么在这个新的序列中，每个⼈报的相应数字为：1,2，3,4....n-2那么这样的话是不是⼜把问题转化成了n-2阶约瑟夫环的问题呢？后⾯的过程与前两次的过程⼀模⼀样，那么递归处理下去，直到最后只剩下⼀个⼈的时候，便可以直接得出结果当我们得到⼀个⼈的时候（即⼀阶约瑟夫环问题）的结果，那么我们是否能通过⼀阶约瑟夫环问题的结果，推导出⼆阶约瑟夫环的结果呢？借助上⾯的分析过程，我们知道，当在解决n阶约瑟夫环问题时，序号为k1的⼈出列后，剩下的n-1个⼈⼜重新组成了⼀个n-1阶的约瑟夫环，那么假如得到了这个n-1阶约瑟夫环问题的结果为ans（即最后⼀个出列的⼈编号为ans），那么我们通过上述分析过程，可以知道，n阶约瑟夫环的结果(ans + k)%n(n为当前序列的总⼈数)，⽽k = m%n则有：n阶约瑟夫环的结果(ans + m % n)%n，那么我们还可以将该式进⾏⼀下简单的化简：当m<n时，易得上式可化简为：（ans + m）% n⽽当m>=n时，那么上式则化简为：（ans % n + m%n%n）% n即为：（ans % n + m%n）% n⽽（ans + m）% n = （ans % n + m%n）% n因此得证(ans + m % n)%n = （ans + m）% n这样的话，我们就得到了递推公式，由于编号是从0开始的，那么我们可以令f[1] = 0； //当⼀个⼈的时候，出队⼈员编号为0f[n] = (f[n-1] + m)%n //m表⽰每次数到该数的⼈出列，n表⽰当前序列的总⼈数⽽我们只需要得到第n次出列的结果即可，那么不需要另外声明数组保存数据，只需要直接⼀个for循环求得n阶约瑟夫环问题的结果即可由于往往现实⽣活中编号是从1-n，那么我们把最后的结果加1即可。
Josephus环问题
Josephus环问题约瑟夫环问题问题描述：Josephus问题可以描述为如下的⼀个游戏：N个⼈编号从1到N，围坐成⼀个圆圈，从1号开始传递⼀个热⼟⾖，经过M次传递后拿着⼟⾖的⼈离开圈⼦，由坐在离开的⼈的后⾯的⼈拿起热⼟⾖继续进⾏游戏，直到圈⼦只剩下最后⼀个⼈。
例如：M=0，N=5，则游戏⼈依次被清除，5号最后留下；如果M=1，N=5，那么被清除的⼈的顺序是2,4,1,5，最后剩下的是3号。
如下是两种解题⽅法：建⽴⼀个N⼤⼩的数组，存储N个⼈是否还在圈⼦内（0为在圈⼦内，-1为已经离开圈⼦），依次循环遍历整个数组，直到剩下的⼈数（left）为1。
public static void pass(int m, int n){int[] num = new int[n];int left = n; //剩下的⼈数int index = 0; //当前遍历到的位置while(left != 1){for(int i = 0; i< m; i++){if(num[index++] != 0) //如果当前⼈已经清除i--;if(index >= n)index = 0;}while(num[index] != 0){index++;if(index >= n)index = 0;}System.out.println("out number is " + (index + 1));num[index] = -1; //将清除的数据下标置-1index++;if(index >= n)index = 0;left--;}}第⼆种⽅式，将1~N的数添加到⼀个ArrayList对列中，⾸先计算偏移量（mPrime），当mPrime⼩于对列长度的⼀半时，则从前往后依次遍历找到清除的元素；当mPrime⼤于对列长度的⼀半时，从后往前遍历找到清除的元素。
public static void pass2(int m, int n){ArrayList<Integer> list = new ArrayList<Integer>();for(int i = 1; i <= n; i++)list.add(i);ListIterator<Integer> iter = list.listIterator();int left = n; //剩下的⼈数int item = 0; //the out numberfor(int i= 1; i < n; i++){int mPrime = m % left;if(mPrime < left/2){ //如果当前的偏移量⼩于list长度的⼀半时if(iter.hasNext())item = iter.next();for(int j = 0; j < mPrime; j++){if(!iter.hasNext())iter= list.listIterator();item = iter.next();}}else{ //当偏移量⼤于list长度的⼀半时，从后往前找for(int j = 0; j< left - mPrime; j++){if(!iter.hasPrevious())iter = list.listIterator(list.size());item = iter.previous();}}System.out.println("out number is " + item);iter.remove();if(!iter.hasNext()) //有可能下⼀次循环mPrime就会⼩于left的⼀半iter = list.listIterator();left--;}}总结当M，N较⼤时，则第⼆种⽅法时间效率更⾼，实现表明，当N=100000，M=9000时（省略的两个算法中的syso语句），⽅法⼀个执⾏时间是30713ms，⽽第⼆种⽅法的执⾏时间仅为4891ms，M越⼤时⽅法⼀的时间效率会更差。
约瑟夫斯问题
约瑟夫斯问题
问题描述
约瑟夫斯问题是一个经典的数学问题，也被称为约瑟夫环问题。
问题的描述如下：有n个人围成一圈，从第一个人开始报数，报到m的人出列，然后从出列的下一个人开始重新报数，再次报到m的人出列，如此循环，直到所有人都出列为止。
那么，最后剩下的人在原来的顺序中编号是几？
算法思路
为了解决约瑟夫斯问题，可以使用一种常用的数学技巧来计算最后剩下的人的编号。
假设n个人的编号分别为0, 1, 2, …, n-1，那么可以得到一个递推公式：
f(n, m) = (f(n-1, m) + m) % n
其中f(n, m)表示有n个人时最后剩下的人的编号。
根据这个递推公式，可以进行递归计算。
算法实现
下面是使用Python语言实现约瑟夫斯问题的算法：
```python def josephus(n, m): if n == 1: return 0 else: return (josephus(n-1, m) + m) % n
测试样例
n = 7 # 总人数 m = 3 # 报数到m时出列 survivor = josephus(n, m) print(。
约瑟夫环问题的两种解法（循环链表和公式法）
约瑟夫环问题的两种解法（循环链表和公式法）问题描述这⾥是数据结构课堂上的描述：N people form a circle, eliminate a person every k people, who is the final survior?Label each person with 0, 1, 2, ..., n - 1, denote(表⽰，指代) J(n, k) the labels of surviors when there are n people.(J(n, k)表⽰了当有 n 个⼈时幸存者的标号)First eliminate the person labeled k - 1, relabel the rest, starting with 0 for the one originally labeled k.0 1 2 3 ... k-2 k-1 k k+1 ... n-1... k-2 0 1 ...Dynamic programmingJ(n, k) = J(J(n - 1, k) + k) % n, if n > 1,J(1, k) = 0⽤中⽂的⽅式简单翻译⼀下就是 (吐槽：为啥课上不直接⽤中⽂呢？淦！) 有 n 个⼈围成⼀圈，从第⼀个⼈开始，从 1 开始报数，报 k 的⼈就将被杀死，然后从下⼀个⼈开始重新从 1 开始报数，往后还是报 k 的⼈被杀掉，杀到最后只剩⼀个⼈时，其⼈就为幸存者。
(上⾯的英⽂是从 0 开始的，是因为我们写程序时使⽤了数组，所以下标从 0 开始)解决⽅案循环链表⽅法算法思路很简单，我们这⾥使⽤了循环链表模拟了这个过程：节点 1 指向节点 2，节点 2 指向节点 3，...，然后节点 N 再指向节点 1，这样就形成了⼀个圆环。
如图所⽰，n 取 12，k 取 3，从 1 开始报数，然后依次删除 3, 6, 9, 12：#include<stdio.h>#include<stdlib.h>typedef struct Node // 节点存放⼀个数据和指向下⼀个节点的指针{int data;struct Node *next;} *NList; // NList为指向 Node 节点的指针// 创建⼀个节点数为 n 的循环链表NList createList(int n){// 先创建⼀个节点NList p, tmp, head;p = (NList)malloc(sizeof(struct Node));head = p; // 保存头节点p->data = 1; // 第⼀个节点for (int i = 2; i <=n ; i++){tmp = (NList)malloc(sizeof(struct Node));tmp->data = i;p->next = tmp;p = tmp;}p->next = head; // 最后⼀个节点指回开头return head;}// 从编号为 1 的⼈开始报数，报到 k 的⼈出列，被杀掉void processList(NList head, int k){if (!head) return;NList p = head;NList tmp;while (p->next != p){for (int i = 0; i < k - 1; i++){tmp = p;p = p->next;}printf("%d 号被杀死\n", p->data);tmp->next = p->next;free(p);p = NULL; // 防⽌产⽣野指针，下同p = tmp->next;}printf("幸存者为 %d 号", p->data);free(p);p = NULL;}int main(){NList head = createList(11);processList(head, 3);return 0;}测试结果：易知，这个算法的时间复杂度为O(nk)，显然，这不是⼀个好的算法。
约瑟夫问题及变种
“约瑟夫”问题及若干变种例1、约瑟夫问题(Josephus)[问题描述]M只猴子要选大王，选举办法如下：所有猴子按1…M编号围坐一圈，从第1号开始按顺序1，2，…，N 报数，凡报到N的猴子退出到圈外，再从下一个猴子开始继续1~ N报数，如此循环，直到圈内只剩下一只猴子时，这只猴子就是大王。
M和N由键盘输入，1≤N,M≤10000，打印出最后剩下的那只猴子的编号。
例如，输入8 3，输出：7。
[问题分析1]这个例题是由古罗马著名史学家Josephus提出的问题演变而来的，所以通常称为Josephus(约瑟夫)问题。
在确定程序设计方法之前首先来考虑如何组织数据，由于要记录m只猴子的状态，可利用含m个元素的数组monkey来实现。
利用元素下标代表猴子的编号，元素的值表示猴子的状态，用monkey[k]=1表示第k只猴子仍在圈中，monkey[k]=0则表示第k只猴子已经出圈。
程序采用模拟选举过程的方法，设变量count表示计数器，开始报数前将count置为0，设变量current 表示当前报数的猴子编号，初始时也置为0，设变量out记录出圈猴子数，初始时也置为0。
每次报数都把monkey[current]的值加到count上，这样做的好处是直接避开了已出圈的猴子（因为它们对应的monkey[current]值为0），当count=n时，就对当前报数的猴子作出圈处理，即：monkey[current]：=0，count：=0，out：=out+1。
然后继续往下报数，直到圈中只剩一只猴子为止（即out=m-1）。
参考程序如下：program josephus1a {模拟法，用数组下标表示猴子的编号}const maxm=10000;var m,n,count,current,out,i:integer;monkey:array [1..maxm] of integer;beginwrite('Input m,n:');readln(m,n);for i:=1 to m do monkey[i]:=1;out:=0; count:=0; current:=0;while out<m-1 dobeginwhile count<n dobeginif current<m then current:=current+1 else current:=1;count:=count+monkey[current];end;monkey[current]:=0; out:=out+1; count:=0end;for i:=1 to m doif monkey[i]=1 then writeln('The monkey king is no.',i);readlnend.[运行结果]下划线表示输入Input m，n:8 3The monkey king is no.7 {时间：0秒}Input m，n:10000 1987The monkey king is no.8544 {时间：3秒}[反思]时间复杂度很大O(M*N)，对于极限数据会超时。
约瑟夫问题的经典三个例子
约瑟夫问题的经典三个例子以下是 9 条关于约瑟夫问题的经典例子：例子 1：想想看，一群小朋友围成一圈玩游戏，就像我们小时候那样。
这时候说从某个小朋友开始报数，每隔一个人淘汰，最后剩下的那个就是胜利者。
这不就是约瑟夫问题嘛。
就好像在一个神秘的游戏圈子里，大家都紧张又兴奋地等待着命运的裁决。
例子 2：你能想象军队里士兵们站成一圈，然后用这种方式来决定谁去执行特殊任务吗？哎呀呀，那场面肯定很刺激。
每个士兵心里都七上八下的，不知道自己是不是那个“幸运儿”，这和约瑟夫问题如出一辙。
例子 3：假如在一场盛大的聚会中，大家玩这样的游戏，是不是超级有趣？就像一个魔法圈，把大家的注意力都吸引过来了。
每淘汰一个人，大家就会一阵惊呼，这不正是约瑟夫问题带来的独特体验嘛。
例子 4：你看过那种生存挑战节目吗？选手们围成一圈，然后通过类似约瑟夫问题的规则来淘汰人。
哇塞，那紧张的氛围，可不就是在经历一场残酷的竞争，这就是约瑟夫问题在现实中的精彩呈现呀！例子5：好比一群探险家在荒岛上，为了分配重要资源而采取这种方式。
每个人都祈祷自己不要被先淘汰掉，这种感觉是不是很奇妙？这就是约瑟夫问题带来的不确定性啊。
例子6：想象一下公司团建的时候玩这个，大家既期待又担心。
“哎呀，可别先轮到我呀！”“哇，我居然留下来了。
”这种种反应，不就是约瑟夫问题的魅力所在吗？例子 7：学校运动会上，各班学生围成一圈进行比赛，多刺激呀！有人欢喜有人忧，这不就是约瑟夫问题所引发的情绪波澜吗？例子 8：在一个神秘的魔法学院里，学生们也用这种方式来选拔优秀学员。
每一个人都全神贯注，这和约瑟夫问题一样充满了悬念呢！例子9：如果在一个古老的部落中，用约瑟夫问题来决定首领的继承人，那该是多么惊心动魄的场面啊。
大家的心都提到了嗓子眼，。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
如何判断已删至最后一个节点？
previous
num
previous->next==previous
节点的删除ቤተ መጻሕፍቲ ባይዱ
previous
p
1
2
3
//输入为指向需要删除节点的前一个节点的指针 void delete_node(link_node* previous) { link_node* p=previous->next; previous->next=previous->next->next; free(p); }
数据结构
typedef struct node { int num; //节点的序号 struct node* next; //指向下 一个结点的指针 }link_node;
num next
1
2
3
循环链表的构造
p
1
2
3
//输入为总人数n //返回指向最后一个节点的指针 link_node* init_link(int n) { int i=1; link_node* head=(link_node*)malloc(sizeof(link_node)); //让p指 向第一个节点 link_node* p=head; p->num=1; //第一个节点的序号为1 i++; for(;i<=n;i++) { p->next=(link_node*)malloc(sizeof(link_node)); //申请下 一个节点的内存，并让前一个节点的next指向下一个节点 p=p->next; //让p指向下一个节点 p->num=i; //对该节点的序号赋值 } p->next=head; //让最后一个节点的next指向第一个节点，形成闭环 return (p); }
约瑟夫环问题
问题回顾
已知n个人（以编号1，2，3...n分别表示） 围坐在一张圆桌周围。从编号为k的人开始 报数，数到m的那个人出列；他的下一个人 又从1开始报数，数到m的那个人又出列； 依此规律重复下去，直到圆桌周围的人全 部出列。
数据结构
把每个人看做一个节点。 整个队伍看成一个循环链表。 用删除节点的方式表示某人出列。