双向约瑟夫环
约瑟夫环问题(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个战友被罗马 军队包围在洞中。他们讨论是自杀还是被 俘，最终决定自杀，并以抽签的方式决定 谁杀掉谁。约瑟夫斯和另外一个人是最后 两个留下的人。约瑟夫斯说服了那个人， 他们将向罗马军队投降，不再自杀。
循环双链表特点
循环双链表特点循环双链表是一种特殊的数据结构，它具有循环和双向链表的特点。
循环双链表中的每个节点都包含两个指针，一个指向前一个节点，一个指向后一个节点。
最后一个节点的后指针指向头节点，头节点的前指针指向最后一个节点，从而形成了一个闭环。
循环双链表的特点如下：1. 双向性：每个节点都有两个指针，分别指向前一个节点和后一个节点。
这样可以方便地在任意位置插入或删除节点，而不需要像单链表那样需要遍历找到前驱节点。
2. 循环性：循环双链表是一个闭环，即最后一个节点的后指针指向头节点，头节点的前指针指向最后一个节点。
这样可以方便地进行循环遍历，不需要判断是否到达了链表的末尾。
3. 动态性：循环双链表可以动态地增加或删除节点，而不需要预先指定链表的长度。
4. 灵活性：循环双链表可以在任意位置插入或删除节点，不受限于只能在链表的头部或尾部进行操作。
这样可以方便地实现栈、队列等数据结构。
5. 代码实现简单：相比于其他数据结构，循环双链表的代码实现相对简单，只需要处理好节点之间的指针关系即可。
循环双链表的应用领域非常广泛，特别是在需要频繁插入和删除节点的场景中，循环双链表能够提供高效的插入和删除操作。
下面以几个具体的应用场景来展开对循环双链表的解释和扩展。
1. 缓存替换算法：循环双链表可以用于实现LRU（Least Recently Used）缓存替换算法。
LRU算法中，当缓存满时，需要替换掉最近最少使用的数据。
循环双链表可以维护数据的访问顺序，每次访问一个数据时，将其移到链表的头部；当缓存满时，删除链表尾部的数据即可。
这样就可以保证链表头部的数据是最近访问的数据，尾部的数据是最久未访问的数据。
2. 轮播图：循环双链表可以用于实现轮播图功能。
轮播图需要循环展示多张图片，循环双链表正好可以满足这个需求。
每个节点表示一张图片，节点之间通过指针连接起来形成一个循环链表。
通过不断地遍历链表，可以实现图片的自动切换。
3. 约瑟夫环问题：循环双链表可以用于解决约瑟夫环问题。
约瑟夫环问题
约瑟夫环问题问题描述：有n个⼈，编号分别从0到n-1排列，这n个⼈围成⼀圈，现在从编号为0的⼈开始报数，当报到数字m的⼈，离开圈⼦，然后接着下⼀个⼈从0开始报数，依次类推，问最后只剩下⼀个⼈时，编号是多少？分析：这就是著名的约瑟夫环问题，关于来历不再说明，这⾥直接分析解法。
解法⼀：蛮⼒法。
我曾将在⼤⼀学c语⾔的时候，⽤蛮⼒法实现过，就是采⽤标记变量的⽅法即可。
解法⼀：循环链表法。
从问题的本质⼊⼿，既然是围成⼀个圈，并且要删除节点，显然符合循环链表的数据结构，因此可以采⽤循环链表实现。
解法三：递推法。
这是⼀种创新的解法，采⽤数学建模的⽅法去做。
具体如下：⾸先定义⼀个关于n和m的⽅程f(n,m)，表⽰每次在n个编号0，1，...，n-1中每次删除的报数为m后剩下的数字，在这n个数字中，第⼀个被删除的数字是(m-1)%n，为了简单，把(m-1)%n记作k，那么删除k之后剩下的数字为0，1，2，...，k-1，k+1，...，n-1并且下⼀次删除的数字从k+1开始计数，这就相当于剩下的序列中k+1排在最前⾯，进⽽形成k+1,..,n-1,0,1,2,...,k-1这样的序列，这个序列最后剩下的数字应该和原序列相同，由于我们改变了次序，不能简单的记作f(n-1,m),我们可以记作g(n-1,m),那么就会有f(n,m)=g(n-1,m).下⼀步，我们把这n-2个数字的序列k+1,..,n-1,0,1,2,...,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-2这样我们可以把这个映射定义为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)，根据映射规则有：g(n-1,m)=p-1[f(n-n,m)]=[f(n-1,m)+k+1]%n,最后把之前的k=(m-1)%n带⼊式⼦就会有f(n,m)=g(n-1,m)=[f(n-1,m)+m]%n.这样我们就可以得出⼀个递推公式，当n=1时，f(n,m)=0;当n>1时，f(n,m)=[f(n-1,m)+m]%n;有了这个公式，问题就变得多了。
约瑟夫生死游戏课程设计(含源代码可以运行)
node* p = head;
int peopleOfNow = totalPeople;
while(peopleOfNow>alivePepole)
{
//找到顺时针要删除节点的前一节点p
for(int i =1; i<num1 - 1;i++)
{
p = p->next;
}
//删除顺时针时的节点
node* toBeDeleted = p->next;
node* tobeDeleted = s->left;
printf("deadman = %d\n",tobeDeleted->value);
node* leftToBeDeleted = tobeDeleted->left;
s->left = leftToBeDeleted;
leftToBeDeleted->next = s;
本游戏的要求用户输入的内容包括：
1. 旅客的个数，也就是n的值；
2. 正向离开旅客的间隔数，也就是m的值；
3. 反向离开旅客的间隔数，也就是k的值；
4. 所有旅客的序号作为一组数据要求存放在某种数据结构中。
本游戏要求输出的内容是包括
1. 离开旅客的序号；
2. 剩余旅客的序号；
所以，根据上面的模型分析及输入输出参数分析，可以定义一种数据结构后进行算法实现。
}
p->next = head;
head->left = p;
return head;
}
3.2 生者与死者的选择
int deleteList(node* head, int num1,int num2,int totalPeople,int alivePepole)//num1代表顺时针数 num2代表逆时针数
细究“约瑟夫环”
细究“约瑟夫环”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 结语约瑟夫环是一个很经典的数学问题，其中的解法多种多样，通过这种复杂的循环可以使我们很轻松的解决一些问题。
约瑟夫环问题课程设计报告
数据结构课程设计报告设计课题：约瑟夫问题院系：计算机科学与技术学院专业班级：计算机网络技术1102班学生姓名：张利学号： 1 1 0 8 0 4 0 2 1 1 指导教师：王昱哲目录1.需求分析 (3)1.1问题描述 (3)1.2功能分析 (4)2.概要设计 (5)3.详细设计 (6)4.调试与操作说明........... 1错误!未定义书签。
总结. (16)一．需求分析1.1问题描述约瑟夫环问题描述的是：设编号为1，2，…，n的n（n>0）个人按顺时针方向围坐一圈，每个人持有一正整数密码。
开始时选择一个正整数作为报数上限m，从第一个人开始顺时针方向自1起顺序报数，报到m时停止报数，报m的人出圈，将他的密码作为新的m值，从他在顺时针方向上的下一个人起重新从1报数。
如此下去，直到所有人都出圈为止。
令n最大值为100。
要求设计一个程序模拟此过程，求出出圈的编号序列。
如下图分析：1.2功能分析约瑟夫环问题是一个古老的数学问题，本次课题要求用程序语言的方式解决数学问题。
此问题仅使用单循环链表就可以解决此问题。
而改进的约瑟夫问题通过运用双向循环链表，同样也能方便地解决。
在建立双向循环链表时，因为约瑟夫环的大小由输入决定。
为方便操作，我们将每个结点的数据域的值定为生成结点时的顺序号和每个人持有的密码。
进行操作时，用一个指针current 指向当前的结点，指针front 始终指向头结点。
然后建立双向循环链表，因为每个人的密码是通过rand()函数随机生成的，所以指定第一个人的顺序号，找到结点，不断地从链表中删除链结点，直到链表剩下最后一个结点，通过一系列的循环就可以解决改进约瑟夫环问题。
图2 约瑟夫环原理演示图二、概要设计1、循环链表抽象数据类型定义typedef struct LNode//定义单循环链表中节点的结构{int num;//编号int pwd;//passwordstruct LNode *next;//指向下一结点的指针}LNode;2、本程序包含一下几个模块（1）构造结点模块LNode *createNode(int m_num,int m_pwd){LNode *p;p=(LNode *)malloc(sizeof(LNode));//生成一个结点p->num=m_num;//把实参赋给相应的数据域p->pwd=m_pwd;p->next=NULL;//指针域为空return p;}（2）创建链表模块void createList(LNode *ppHead,int n)（3）出队处理模块void jose(LNode *ppHead,int m_pwd)（4）约瑟夫环说明输出模块void instruction()（5）菜单模块void menu()（6）主函数模块int main（）函数的调用关系图如下：三、详细设计1.主函数图4 主函数数据流程图根据流程图，主函数程序如下：int main(){int n,m,x;LNode *ppHead=NULL;menu();for(;;){printf("\n请选择要执行的操作：");scanf("%d",&x);system("cls");switch(x){case 1:printf("************************************************************ ****\n");printf("约瑟夫环:\n");printf(" 编号为1,2,3,4…,n的n个人按顺时针方向围坐一圈,每人持有一个密\n");printf("码(正整数).一开始任选一个正整数作为报数的上限值m,从第一个人开始\n");printf("按顺时针方向自1开始顺序报数,报到m时停止.报m的人出列，将他的密码\n");printf("m作为新的m值,从他在顺时针方向上的下一人开始重新从1报数,如此下去,\n");printf("直到所有人全部出列为止.编程打印出列顺序.\n");printf("************************************************************ ****\n");main();break;case 2:printf("\n请输入总人数n：");scanf("%d",&n);printf("请输入开始上限数m：");scanf("%d",&m);createList(&ppHead,n);printf("\n");printf("出队顺序：\n");jose(ppHead,m);printf("\n约瑟夫环游戏结束!\n");main();break;case 0:exit(0);default:system("cls");printf("\n您选择的操作有误，请重新选择...\n\n\n");main();}}return 0;}2.链表的创建图5 创建链表函数的数据流程图/*创建单向循环链表ppHead，人数个数为n，并输入每个人的密码值，若建立失败则生成头结点，让cur指向他，若建立成功则插入结点P，cur指向的数据元素为p,后续为"空"的节点，再把P插入循环链表ppHead中*/根据流程图，创建链表函数程序如下：void createList(LNode **ppHead,int n){int i,m_pwd;LNode *p,*cur;//cur:浮标指针for(i=1;i<=n;i++){printf("输入第%d个人的密码：",i);scanf("%d",&m_pwd);//输入持有密码p=createNode(i,m_pwd);//调用构造结点函数if(*ppHead==NULL)//如果头结点为空{*ppHead=cur=p;//生成头结点，让cur指向他cur->next=*ppHead;//cur的指针域指向自身}else//如果不为空，则插入结点{p->next = cur->next;cur->next = p;cur= p;//cur指向新插入结点}}printf("完成创建！\n"); //提示链表创建完成}3.出队处理图6 出队函数的数据流程图/*p指向要删除节点的前一个节点，ppHead指向要删除的节点，使p=ppHead，ppHead再指向要删除节点的下一个节点，使p和ppHead链接，输出p指向节点的编号和密码值，释放ppHead，如此循环，直至把所有节点都打印和删除为止！*/根据流程图，出队函数程序如下：void jose(LNode *ppHead,int m_pwd){int i,j;LNode *p,*p_del;//定义指针变量for(i=1;p!=ppHead;i++){for(j=1;j<m_pwd;++j){p=ppHead;//p赋值为ppHead，p指向要删除结点的前一个结点ppHead=ppHead->next;//ppHead指向下一个元素}p->next = ppHead->next;//p结点与头结点链接i=ppHead->pwd;//i赋值为ppHead->pwdj=ppHead->num;//j赋值为ppHead->num，j为要删除的密码值printf("第%d个人出列，密码：%d\n",j,i);m_pwd=ppHead->pwd;//m_pwd赋值为ppHead->pwdfree(ppHead);//释放头结点ppHead=p->next;//ppHead重新赋值给p->next,即释放前的ppHead->pwd指针//删除报数结点}i=ppHead->pwd;//i赋值为ppHead->pwdj=ppHead->num;//j赋值为ppHead->numprintf("最后一个出列是%d号，密码是:%d\n",j,i);free(ppHead);//释放头结点}4. 约瑟夫环说明模块void instruction(){printf("************************************************************ ****\n");printf("约瑟夫环:\n");printf(" 编号为1,2,3,4…,n的n个人按顺时针方向围坐一圈,每人持有一个密\n");printf("码(正整数).一开始任选一个正整数作为报数的上限值m,从第一个人开始\n");printf("按顺时针方向自1开始顺序报数,报到时停止.报m的人出列，将他的密码\n");printf("m作为新的m值,从他在顺时针方向上的下一人开始重新从1报数,如此下去,\n");printf("直到所有人全部出列为止.编程打印出列顺序.\n");printf("******************************************************\n");return 0;}5. 菜单模块void menu(){printf("**************************约瑟夫环*****************************\n");printf(" \n");printf(" [1]约瑟夫环问题的阐述\n");printf(" [2]按要求求解约瑟夫环\n");printf(" [0]退出\n");printf("************************** 欢迎使用！****************************\n");}四、程序调试与测试1. 调用模块时，结点结构的调用与其他模块产生冲突，导致每一行都出现两次错误，加入子函数的声明后错误消失。
约瑟夫之谜的名词解释
约瑟夫之谜的名词解释约瑟夫之谜：逃避死亡的智慧在古老的历史长河中，有许许多多的谜团流传至今，其中一道引人瞩目的谜题，就是约瑟夫之谜。
这个谜题如同一道脑筋急转弯，令人陷入思考的深渊中。
究竟什么是约瑟夫之谜？本文将以一种旁征博引的方式，深入探讨这个神奇而又深沉的谜题。
约瑟夫之谜，也被称为约瑟夫环问题，源自古罗马时期。
据传，约瑟夫是一位年纪轻轻却头脑聪慧的犹太人。
敌对的罗马军队包围了他的城市，他们的终极目标就是夺取约瑟夫的性命。
为了逃过一劫，约瑟夫和他的朋友们决定采取一种不同寻常的生存策略。
命运的时间步骤过于残酷：每隔一定的时间，罗马军队会选择一个固定的顺序排列的人杀掉。
为了保住自己的生命，约瑟夫们决定在一个迷人而又难解的游戏中挣扎。
他们决定按照固定的顺序围着一个圆圈坐下，每当轮到某个人遭到宣判时，他后面的人会立即被杀掉。
当约瑟夫和他的朋友们面对这个可怕而又无情的游戏时，他们拥有一个独特的优势：他们都是聪明的思考者。
他们知道，唯一可以保证自己生命延续的方法就是找到一个特殊的座位，以便在他们被罗马军队宣判之前逃走。
而解决此难题的方法，正是约瑟夫之谜的核心。
约瑟夫和他的朋友们经过长时间的思考和讨论，最终得出结论：他们必须假装接受宣判并立即逃走。
他们以此方式不断循环，直到只剩下最后一个人。
通过观察若干个这样的循环，他们发现一个神奇的数学准则：最后一个幸存者的座位总是环中的第n个人。
找到这个规律之后，约瑟夫和他的朋友们在面对死亡的恐惧时，找到了一丝希望和智慧。
他们可以以这种方式延长自己的存活时间，尽管最终没有人能够永远逃脱。
但这个故事中的约瑟夫告诉我们，面对绝望时，思考和创新是人类的强大武器。
约瑟夫之谜，通过一种看似无意义的数学模式，揭示了我们在面对逆境时的思考方式。
这个谜题也引起了许多数学家和研究者的兴趣，他们试图寻找背后的数学规律和解释。
在当代，约瑟夫之谜被广泛应用于许多领域，如计算机科学、游戏理论和密码学等。
趣学算法——约瑟夫环问题（java版）
趣学算法——约瑟夫环问题（java版）1 什么是约瑟夫环问题？约瑟夫，是⼀个古犹太⼈，曾经在⼀次罗马叛乱中担任将军，后来战败，他和朋友及另外39个⼈躲在⼀⼝井⾥，但还是被发现了。
罗马⼈表⽰只要投降就不死，约瑟夫想投降，可是其他⼈坚决不同意。
怎么办呢，他想到⼀个主意：让41个⼈围成⼀个圆圈，从第⼀个⼈开始报数，数到3的那个⼈被旁边的⼈杀死。
这样就可以避免⾃杀了，因为犹太⼈的信仰是禁⽌⾃杀的。
结果⼀群⼈杀来杀去最后只剩下两个了，就是约瑟夫和他朋友，于是两⼈愉快地去投降了。
约瑟夫和朋友站在什么位置才保住了性命呢，这就是我们今天要讲的约瑟夫环问题。
2 问题的重要性这是个BAT常⽤⾯试题，⽽且本质上是⼀个游戏，可以⼴泛应⽤于⽣活中，⼯作⽣活好帮⼿就是它了。
3 约瑟夫环抽象问题这个问题实际在讲：N个⼈围成⼀圈，第⼀个⼈从1开始报数，报M的被杀掉，下⼀个⼈接着从1开始报，循环反复，直到剩下最后⼀个，那最后胜利者的初始位置在哪⾥？模拟流程：假如有5个⼈报数，报到3被杀，情况如下A B C1 D E （初始位置，C第⼀个被杀）D E A2 B (C死后的第⼆次排位，A第⼆个被杀)B D E3 (A死后的第三次排位，E第三个被杀)B4 D (E死后的第四次排位，B第四个被杀)D (D留在了最后，初始位置是4)解决⽅法：1 循环遍历法public static int josephus(int n, int m) {//n个⼈, 0 1 2..n-1int[] people = new int[n];//⼈的索引int index = -1;//报数记录, 1 2 3..mint count = 0;//剩余⼈数初始值为nint remain = n;//为了找到最后⼀个幸存者的位置，假设所有⼈都会被杀while (remain > 0) {index++; //找到报数的⼈if (index == n) { //所有⼈遍历⼀圈后从头遍历index = 0;}if (people[index] == -1) { //如果当前的⼈被杀跳过continue;}count++; //报数if (count == m) {people[index] = -1; //报数到m后杀⼈count = 0; //报数重置remain--; //剩余⼈数递减}}return index;}将41传⼊⽅法后，可得结果为30, 因为是从0开始计数，所以等价于现实世界的第31位。
约瑟夫环 实验报告
约瑟夫环实验报告约瑟夫环实验报告引言：约瑟夫环是一个经典的数学问题，它源自于古代传说。
根据传说，古代犹太人被罗马人围困在一个洞穴中，他们决定用一种特殊的方式来决定谁将成为首领。
他们站成一个圆圈，从一个人开始，每隔一个人杀掉一个，直到只剩下一个人。
这个问题被称为约瑟夫环问题，它在数学领域引起了广泛的研究和探讨。
实验目的：本实验旨在通过模拟约瑟夫环问题，探讨其数学规律和解法，并分析实验结果的意义和应用。
实验步骤：1. 首先，我们需要确定参与约瑟夫环的人数n和每次报数的间隔m。
在本次实验中，我们选择了n=10和m=3。
2. 接下来，我们将10个人按顺序排成一个圆圈，并给每个人编号，编号从1到10。
3. 实验开始时，从第一个人开始报数，每次报数到m的人将被淘汰出局。
4. 淘汰的人将离开圆圈，下一个人将从淘汰者的下一个人开始报数，继续进行报数和淘汰的过程，直到只剩下一个人为止。
实验结果：通过模拟实验，我们得到了以下结果：- 第一轮淘汰的人依次为：3、6、9、2、7、1、8、5、10。
- 第二轮淘汰的人依次为：4、9、2、8、5、1、7、6。
- 第三轮淘汰的人依次为：9、8、5、1、7、4、6。
- 第四轮淘汰的人依次为：1、7、4、6、9、5。
- 第五轮淘汰的人依次为：7、4、6、9、5。
- 第六轮淘汰的人依次为：4、6、9、5。
- 第七轮淘汰的人依次为：6、9、5。
- 第八轮淘汰的人依次为：9、5。
- 第九轮淘汰的人依次为：5。
结论：通过实验结果的分析，我们可以得出以下结论：1. 在本次实验中，最后幸存的人是编号为5的人。
2. 根据实验结果，我们可以总结出约瑟夫环问题的一般解法。
假设总人数为n，每次报数的间隔为m，最后幸存的人的编号可以通过递归公式f(n,m)=[f(n-1,m)+m]%n得到。
3. 约瑟夫环问题在数学中具有一定的研究价值和应用意义。
它涉及到递归、数论等数学概念和方法，可以帮助我们更好地理解和应用这些数学知识。
约瑟夫环问题的两种解法（详解）
约瑟夫环问题的两种解法（详解）约瑟夫环问题的两种解法（详解）题⽬：Josephus有过的故事：39 个犹太⼈与Josephus及他的朋友躲到⼀个洞中，39个犹太⼈决定宁愿死也不要被敌⼈抓。
于是决定了⾃杀⽅式，41个⼈排成⼀个圆圈，由第1个⼈开始报数，每报数到第3⼈该⼈就必须⾃杀。
然后下⼀个重新报数，直到所有⼈都⾃杀⾝亡为⽌。
然⽽Josephus 和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与⾃⼰安排在第16个与第31个位置，于是逃过了这场死亡游戏。
对于这个题⽬⼤概两种解法：⼀、使⽤循环链表模拟全过程⼆、公式法我们假设这41个⼈编号是从0开始，从1开始报数，第3个⼈⾃杀。
1、最开始我们有这么多⼈：[ 0 1 2 3 4 5 ... 37 38 39 40 ]2、第⼀次⾃杀，则是(3-1)%41=2 这个⼈⾃杀，则剩下：[ 0 1 3 4 5 ... 37 38 39 40 ]3、然后就是从编号为3%41=3的⼈开始从1报数，那么3号就相当于头，既然是头为什么不把它置为0，这样从它开始就⼜是与第1,2步⼀样的步骤了，只是⼈数少了⼀个，这样不就是递归了就可以得到递归公式。
想法有了就开始做：4、把第2步中剩下的⼈编号减去3映射为：[ -3 -2 0 1 2 ... 34 35 36 37 ]5、出现负数了，这样不利于我们计算，既然是环形，37后⾯报数的应该是-3，-2，那么把他们加上⼀个总数（相当于加上360度，得到的还是它）[ 38 39 0 1 2 3 ... 34 35 36 37 ]6、这样就是⼀个总数为40个⼈，报数到3杀⼀个⼈的游戏。
这次⾃杀的是第5步中的(3-1)%40=2号，但是我们想要的是第2步中的编号（也就是最初的编号）那最初的是多少？对应回去是5；这个5是如何得到的呢？是（2+3)%41得到的。
⼤家可以把第5步中所有元素对应到第2步都是正确的。
7、接下来是[ 35 36 37 38 0 1 2... 31 32 33 34 ]⾃杀的是(3-1)%39=2，先对应到第5步中是(2+3)%40=5，对应到第2步是(5+3)%41=8。
约瑟夫环——递推公式
0123456789 12345678910 4567891012 789101245 10124578 4578101
810145
45810
1045
104
4约瑟夫环——递推公式
递推公式：
f(N,M)=(f(N−1,M)+M)%N
f(N,M)表⽰，N个⼈报数，每报到M时杀掉那个⼈，最终
f(N−1,M)表⽰，N-1个⼈报数，每报到M时杀掉那个⼈，最终胜利者的编号
现在假设有10个⼈，报到3的⼈就会被杀掉，我们⽤数字给这⼗个⼈编号为
1 2 3 4 5 6 7 8 9 10
第·⼀⾏绿⾊那⾏是数组下标，第⼆⾏是每个⼈的编号
现在逆向推导
f(1,3):只剩最后⼀个⼈，胜利者的数组下标为0
f（2,3）=(f(1,3)+3)%2=1,只有两个⼈的时候，胜利者下标为1。
f（10,3）=3，因为我们数组下标是从0开始的，所以⼈的编号是下标+1，也就是4
那么这个公式是怎么推导的呢？
1.假设我们已经知道了10个⼈时，胜利者的下标为3，那下⼀次9个⼈时，胜利者的下标为多少？
其实就是10个⼈时杀掉了编号为3（即数组下标为2）的⼈后，后⾯的⼈都往前移动了3位，所以胜利者的下标由3变成了0
2.那我们倒过来我们知道9个⼈时，胜利者的下标为0，那10个⼈时胜利者的下标为多少？
其实这和上⾯的问题⼀样，这是这是上个问题的逆过程，就是把⼤家都往后移动3位，所以f(10,3)=f(9,3)+3,不过可能会出现数组越界所以要取模变成f（10,3）=（f（9,3）+3）%10
3.那么⼈数改为n报到m时就杀掉数组怎么移动呢
⼀样的，杀⼀⼈则后⾯的⼈的下标都往前移动m则，f（n，m）=（f（n-1，m）+m）%n。
循环队列之约瑟夫环问题
循环队列之约瑟夫环问题约瑟夫问题 约瑟夫环（约瑟夫问题）是⼀个数学的应⽤问题：已知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位幸存者。
约瑟夫环问题实验报告
//报数为m的人出列
while(n--)
{
for(int s=m-1; s--; r=p, p = p->link);
cout << "The output is: " << p->data << endl;
r->link = p->link;
LinkList d = new LNode;
if(!d)
二、实验问题描述
设编号为1，2，···，n的n个人围坐一圈，约定编号为k（1≤k≤n）的人从1开始报数，数到m的那个人出列，他的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
3、实验步骤
1、实验问题分析
①由于当某个人退出圆圈后，报数的工作要从下一个人开始继续，剩下的人仍要是围成一个圆圈，可以使用循环表；由于退出圆圈的工作对应着表中结点的删除操作，对于这种删除操作频繁的情况，应该选用效率较高的链表结构；为了程序指针每一次都指向一个具体的代表一个人的结点而不需要进行判断，链表不带表头结点。所以，对于所有人围成的圆圈所对对应的数据结构采用一个不带头结点的循环链表来描述。设头指针为p，并根据具体情况移动
可以采用数据类型定义： Typedef struct node {
int number;
struct node *next; }Lnode,*Linklist;
②为了记录退出的人的先后顺序，采用一个顺序表进行存储，程序结束后再输入依次退出的人的编号顺序。由于只记录各个结点的number值就可以，所以定义一个整型一维数组。如“int quite[N];”N为一个根据实际问题定义的一个足够大的整数。
约瑟夫环问题知识点总结
约瑟夫环问题知识点总结约瑟夫环问题的描述如下：有n个人（编号从1到n），他们围成一个环形。
从第一个人开始报数，数到m的人被杀掉，然后从被杀掉的人的下一个人开始重新报数，直到所有人都被杀掉为止。
问题的解是最后剩下的那个人的编号。
约瑟夫环问题在计算机科学和数学领域都有着广泛的应用，因为它涉及到循环队列、递归、数学归纳法等多个概念。
以下是约瑟夫环问题的一些重要知识点总结：1. 约瑟夫环问题的递归解法递归是解决约瑟夫环问题的一种常见的方法。
基本思路是将问题分解为规模更小的子问题，并通过解决子问题来解决原始问题。
对于约瑟夫环问题来说，递归的解法是通过递归地计算每轮的幸存者，直到只剩下一个人为止。
递归解法的关键是找到问题的递归关系。
具体而言，对于约瑟夫环问题，如果用f(n, m)表示n个人中最后幸存者的编号，那么可以得出如下的递归关系：f(n, m) = (f(n-1, m) + m) % n其中，%表示取模运算。
该递归关系表明，当有n个人的时候，最后幸存者的编号可以通过n-1个人的最后幸存者的编号计算得到。
2. 约瑟夫环问题的迭代解法除了递归解法之外，约瑟夫环问题还可以通过迭代的方式进行求解。
迭代解法的基本思路是模拟报数和杀人的过程，直到最后只剩下一个人为止。
迭代解法的关键是找到每一轮报数的规律。
具体而言，对于约瑟夫环问题，可以用一个循环队列来模拟报数的过程，每次报数到第m个人就将其从队列中移除。
通过不断循环这个过程，最终可以得到最后幸存者的编号。
3. 约瑟夫环问题的数学解法约瑟夫环问题还可以通过数学的方法进行求解。
具体而言，可以利用数学归纳法来推导出约瑟夫环问题的解析表达式。
这种方法的优点是可以更快地得到结果，但是需要一定的数学推导能力。
通过数学推导，可以得到约瑟夫环问题的解析表达式：f(n, m) = (f(n-1, m) + m) % n其中，f(1, m) = 0。
该表达式可以直接求解出最后幸存者的编号。
约瑟夫环问题详解
约瑟夫环问题详解很久以前，有个叫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]输出，然后将后⾯的值往前移动⼀位，直到所有的节点出列。
约 瑟 夫 环 问 题 的 三 种 解 法
约瑟夫问题(数学解法及数组模拟)约瑟夫问题（有时也称为约瑟夫斯置换，是一个出现在计算机科学和数学中的问题。
在计算机编程的算法中，类似问题又称为约瑟夫环。
又称“丢手绢问题”.）据说著名犹太历史学家 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就能得到原来的编号。
精品约瑟夫环课程设计
精品 约瑟夫环课程设计一、课程目标知识目标：1. 学生能理解约瑟夫环的概念，掌握其数学模型及相关术语。
2. 学生能够运用所学知识解决约瑟夫环问题，如计算生存者位置、推导出递推公式等。
3. 学生了解约瑟夫环问题在计算机科学、数学等领域的应用。
技能目标：1. 学生通过分析约瑟夫环问题，培养逻辑思维和问题解决能力。
2. 学生能够运用编程语言实现约瑟夫环问题的求解，提高编程能力。
3. 学生通过小组讨论，学会合作学习，提高团队协作能力。
情感态度价值观目标：1. 学生在解决约瑟夫环问题的过程中，体验数学和计算机科学的趣味性，培养学科兴趣。
2. 学生通过面对挑战，克服困难，培养坚持不懈、勇于探索的精神。
3. 学生了解约瑟夫环问题背后的历史故事，激发对科学家的敬仰之情，树立正确的价值观。
课程性质：本课程为信息技术与数学跨学科课程，结合实际问题，培养学生的逻辑思维、编程能力和团队协作精神。
学生特点：学生处于高年级阶段，具备一定的数学基础和编程能力，对新鲜事物充满好奇心，喜欢挑战性任务。
教学要求：课程注重理论与实践相结合，以学生为主体，鼓励学生主动探究、合作学习，充分调动学生的积极性。
通过本课程的学习，使学生能够将所学知识应用于实际问题的解决中。
二、教学内容1. 约瑟夫环概念介绍：通过故事引入约瑟夫环问题，讲解其背景和基本原理，使学生理解问题的实质。
教材章节：第五章“递推与递归”第一节“约瑟夫环问题”2. 约瑟夫环数学模型：引导学生建立数学模型，推导递推公式，探讨求解方法。
教材章节：第五章“递推与递归”第一节“约瑟夫环问题”3. 编程求解约瑟夫环问题：介绍编程语言中的循环、条件语句等基本语法，指导学生编写程序求解约瑟夫环问题。
教材章节：第六章“程序设计基础”第二节“循环结构与应用”4. 约瑟夫环问题拓展与应用：分析约瑟夫环问题在计算机科学、数学等领域的应用，提高学生的问题解决能力。
教材章节：第五章“递推与递归”第三节“递归算法与应用”5. 小组合作与实践：组织学生进行小组讨论，共同解决约瑟夫环问题，分享编程经验和心得。
[LeetCode]约瑟夫环问题（剑指offer62）
![[LeetCode]约瑟夫环问题（剑指offer62）](https://img.taocdn.com/s3/m/3044766203768e9951e79b89680203d8ce2f6a0b.png)
[LeetCode]约瑟夫环问题（剑指offer62）
约瑟夫环问题是⼀个经典的数学问题，背景故事参考百度百科，其原始问题如下：
0,1,,n-1这n个数字排成⼀个圆圈，从数字0开始，每次从这个圆圈⾥删除第m个数字。
求出这个圆圈⾥剩下的最后⼀个数字。
⽐较直接的想法是通过链表模拟游戏，直到最后只剩⼀个元素，但这样的时间复杂度是O(nm)，显然不⾏。
类似问题通过数学⽅法找到规律会简单的多，其实很多递归以及动态规划题⽬也是通过数学⽅法找递推式即可简单解出。
记上述问题的解为f(n,m)。
则第⼀个被删除的数为(m-1)%n。
此时，转化为由m%n开始的，规模为(n-1,m)的相同问题结构约瑟夫环问题。
所以此问题可以通过递归来求解，但要知道每次迭代之后，新元素和就元素的⼀⼀对应关系。
以第⼀次迭代为例：
把新元素编号记为x，旧元素编号记为y，那么新旧编号的对应公式为
y = (x + m) % n
由此可得
f(n,m) = (f(n-1,m) + m) % n n>1
f(1,m) = 0
public int lastRemaining(int n, int m) {
int f = 0;
for (int i = 2; i <= n; i++) {
f = (f + m) % i;
}
return f;
}
其中f是f(1,m)的解。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
双向约瑟夫环
代码：
#include<iostream>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
using namespace std;
struct DataType
{
char name[10];
char num[9];
char gender[3];
int age;
char work[5];
char health[10];
};
struct Node
{
DataType data;
Node *next;
Node *prior;
};
void PrintData(DataType data)
{
printf("%s%s%s%d%s%s\n", , data.num, data.gender, data.age, data.work, data.health);
}
Node *CreateList(Node *L,int n)
{
Node *q;
int i;
for(i = 1; i <= n; i++)
{
Node *p;
p=new Node;
// InitData(p->data);
scanf("%s%s%s%d%s%s", p->, p->data.num,
p->data.gender, &p->data.age, p->data.work, p->data.health);
p->next=NULL;
if(i==1) L=q=p;
else
{
q->next=p;
p->prior = q;
q=q->next;
}
}
q->next=L;
L->prior = q;
return(L);
}
/*int LengthList(Node *L)
{
int i=1;
Node *p=L->next;
while(p!=L)
{
i++;
p=p->next;
}
return(i);
}*/
Node *DeleteListNext(Node *&L,int i,Node *q)
{
//if(i==1) i+=LengthList(*L);
Node *p;
p = L;
int j = 0;
while(j < i-2)
{
p = p->next;
j++;
}
q = p->next;
//PrintData(q->data);
p->next=q->next;
// delete q;
// q = NULL;
L = p->next;//or &q;
L->prior = p;
// cout<<endl;
// PrintData(L->data);
// cout<<endl;
return q;
}
Node *DeleteListPrior(Node *&L,int i,Node *q)
{
//if(i==1) i+=LengthList(*L);
Node *p;
p = L;
int j = 0;
while(j < i-2)
{
p = p->prior;
j++;
}
q = p->prior;
//PrintData(q->data);
p->prior = q->prior;
L = q->prior;
L->next = p;
//or &q;
// delete q;
// q = NULL;
return q;
}
void Joseph(Node *L,int max, int step1, int step2)//双向链表前驱后继都要更改{
int i;
for(i=1; i < max; i++)
{
Node *q = new Node;
if(i == 1) q = DeleteListNext(L, step1, q);
else if(i%2)
q = DeleteListNext(L, step1, q);
else
q = DeleteListPrior(L, step2, q);
PrintData(q->data);
delete q;
q = NULL;
}
PrintData(L->data);
}
int main()
{
Node *L;
L=NULL;
int max, step1, step2;
scanf("%d%d%d", &max, &step1, &step2);
L = CreateList(L, max);
Joseph(L, max, step1, step2);
free(L);
return 0;
}。