约瑟夫环问题可视化
- 格式:docx
- 大小:14.87 KB
- 文档页数:8
约瑟夫环实验报告约瑟夫环是一个经典的数学问题,它涉及到一个有趣的游戏。
这个游戏的规则是:有N个人站成一圈,从某个人开始,每报数到第M个人,就将该人从圈中移出去,再从下一个人开始重新报数,如此循环,直到只剩下一个人为止。
那么,我们将通过实验来探究一下约瑟夫环的性质和一些有趣的现象。
首先,我们设定了一组实验条件。
假设有10个人,从1到10编号,报数为3。
我们选择从编号为1的人开始报数,然后每次报数到第3个人。
接下来,我们按照约瑟夫环的规则进行实验。
实验开始后,我们可以观察到一系列有趣的现象。
首先,被淘汰的人并不会立即离开圈子,而是继续留在原位,但不再参与后续的报数和淘汰。
当每次报数到达M的倍数时,即到了第3个人、第6个人、第9个人等等,这些人就会被逐渐淘汰出圈。
在实验过程中,我们发现了一个有趣的规律。
剩下的人似乎总是固定按照一定的顺序被淘汰。
为了更好地观察这个规律,我们进行了多组实验,并记录了淘汰顺序。
首先,在报数为3的情况下,我们记录了当有10个人时的淘汰顺序。
开始时,第1轮淘汰的是第3个人,然后是第6个人,之后是第9个人。
接着,轮到第2个人被淘汰,然后是第7个人,最后是第1个人。
可见,在这个实验条件下,被淘汰的顺序是3、6、9、2、7、1。
我们可以看到,在最后几轮淘汰时,被淘汰的顺序逐渐回到了初始的编号1。
接着,我们将实验条件略作改变,观察是否会出现相似的淘汰顺序。
这次,我们依然有10个人,报数为4。
开始时,第1轮淘汰的是第4个人,然后是第8个人,之后是第2个人。
接着,轮到第5个人被淘汰,然后是第10个人,最后是第6个人。
通过这次实验,我们可以观察到一些不同之处。
尽管淘汰的顺序在最后几轮回到了初始的编号1,但淘汰的间隔变得更长了,而且整体的淘汰顺序也有了一定的变化。
通过对约瑟夫环实验的多次观察和记录,我们可以总结出一些结论。
首先,淘汰的顺序呈现出周期性,并在最后几轮回到了初始的编号。
其次,在不同的实验条件下,淘汰的规律可能会有所不同。
约瑟夫环问题实习报告题目:约瑟夫环(Joseph)问题的一种描述是:编号为1,2,…,n的n个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。
一开始人选一个正整数作为报数上限值m,从第一个人开始按顺时针方向自1开始顺序报数,报到m时停止报数。
报m的人出列,将他的密码作为新的m值,从它在顺时针方向的下一个人开始重新从1报数,如此下去,直至所有人全部出列为止。
试设计一个程序求出出列顺序。
班级:姓名学号:完成日期:2007年10月15日一、需求分析1.本程序中,利用单向循环链表存储结构存储约瑟夫环数据(即n个人的编号和密码)。
2.本程序以用户和计算机的对话方式执行,即在计算机终端上显示"提示信息"之后,由用户在键盘上输入演示程序中需要输入的数据,运算结果显示在其后。
3.程序执行的命令包括:1)构造单向循环链表;2)初始化单向循环列表;3)处理出列顺序;4)结束。
4.测试数据m 的初值为20;n=7,7个人的密码依次为:3,1,7,2,4,8,4,首先m值为6(正确的出列顺序为6,1,4,7,2,1,3,5)。
5.概要设计为了实现上述程序功能,应以单向循环链表存储约瑟夫环数据,为此,需要数据类型为单项循环链表。
1.单向循环链表的抽象数据类型定义为:ADT List{数据对象:D={ai | ai∈正整数,I=1,2,......,n,n≥0}数据关系:R1={< ai-1,ai > |,ai-1,ai∈D,I=1,2,......,n}基本操作:InitList(&L)操作结果:构造一个空的线性表L。
InsElem(&L,i,e)初始条件:线性表L已存在,1≤i≤List Length(L)+1.操作结果:在L中第i个位置之前插入新的数据无素e,L长度加1。
DelElem(&L,i,&e)初始条件:线性表L存在非空,1≤i≤List Length(L).操作结果:删除L的第i个元素,并用e返回其值,L长度减12.本程序由三部分组成:1)主程序部分2)单循环链表初始化部分3)处理出列数据部分3.程序所要执行的命令如下:构造一个循环链表,给新的变量利用new动态分配空间,进行赋值,并且用链表结构进行删除操作,直到最后一个节点被删除为止.三、详细设计1.元素类型和结点类型struct LNode{int data,code;LNode *next;};初始化循环链表部分:void Create(LNode *head){LNode *p;int i;printf("输入各人密码:");head->data=1;scanf("%d",&head->code) ;p=head;for(i=2;i<=n;i++){LNode *s=new LNode;s->data=i;scanf("%d",&s->code);p->next=s;p=s;}p->next=head;}处理出列顺序部分:int Put(LNode *q){int i;LNode *p;p=q;while(n!=1){for(i=2;i<=m;i++){q=p;p=p->next;}q->next=p->next;//删除节点m=p->code;printf("%d",p->data);free(p);p=q->next;}return p->data;}四、调试分析1.开始时对一些循环条件设置错误,导致程序运算结果错误,后来经过推敲写出了正确的循环结束条件。
约瑟夫环上机实验报告1. 概述约瑟夫环问题是一个经典的数学问题,该问题是以约瑟夫·弗拉维奥(Josephus Flavius)命名的,故称为约瑟夫环。
问题的具体描述如下:在编号为1到n的n 个人围成一个圆圈,从第一个人开始报数,报到m的人出列,然后从出列的下一个开始重新从1到m报数,再次报到m的人再次出列,如此循环下去,直到所有的人都出列为止。
本次实验旨在使用程序实现约瑟夫环的模拟,并观察对于不同的参数n和m,最后剩余的人的编号特点。
2. 实验设计2.1 算法设计本实验中采用循环链表来模拟约瑟夫环,首先构建一个含有n个结点的循环链表,每个结点表示一个人,每个结点的数据域存储该人的编号。
然后根据报数规则,依次遍历链表,当报数为m时,删除对应的结点。
直到链表中仅剩一个结点为止。
2.2 程序实现pythonclass ListNode:def __init__(self, val=0):self.val = valself.next = Nonedef josephus(n, m):if n == 0:return -1构建循环链表dummy = ListNode(-1)cur = dummyfor i in range(1, n + 1):node = ListNode(i)cur.next = nodecur = cur.nextcur.next = dummy.next模拟游戏过程count = 0while cur.next != cur:count += 1if count == m:cur.next = cur.next.nextcount = 0else:cur = cur.nextreturn cur.val3. 实验结果为了观察不同参数n和m对最后剩余的人的编号的影响,我们进行了多组实验。
结果如下:n m 最后剩余的人的编号5 2 310 3 415 4 1420 5 6从实验结果可以看出,最后剩余的人的编号与参数m有关,而与参数n无关。
数据结构实验报告约瑟夫环约瑟夫环是一个古老而有趣的问题,也是数据结构中一个经典的应用。
它的故事发生在公元前1世纪,当时犹太人正面临罗马的入侵。
为了避免被俘虏,一群犹太士兵决定以一种特殊的方式自杀,而不是被罗马人俘虏。
他们围成一个圈,按照某个规则进行自杀,直到只剩下一个人为止。
这就是著名的约瑟夫环问题。
在这个问题中,我们有n个人,编号从1到n,围成一个圈。
按照一定的规则,从第一个人开始报数,每次报到m的人将被淘汰。
然后,从下一个人开始重新报数,如此循环,直到只剩下一个人为止。
这个问题的解决方法有很多,其中最常见的是使用链表数据结构。
我们可以将每个人表示为一个节点,节点之间通过指针连接,形成一个环形链表。
每次淘汰一个人后,只需要将指针跳过被淘汰的节点,重新连接链表。
为了更好地理解这个问题,我们可以通过一个简单的例子来演示。
假设有10个人,编号从1到10,每次报数到3的人将被淘汰。
首先,我们将这10个人表示为一个环形链表:1->2->3->4->5->6->7->8->9->10->1。
按照规则,第一次报数到3的人是3号,所以我们将3号节点从链表中删除:1->2->4->5->6->7->8->9->10->1。
接下来,从4号节点开始重新报数。
第二次报数到3的人是6号,所以我们再次将6号节点从链表中删除:1->2->4->5->7->8->9->10->1。
以此类推,直到只剩下一个人为止。
通过这个例子,我们可以看到约瑟夫环问题的解决方法非常简单直观。
使用链表数据结构,每次淘汰一个人后,只需要将指针跳过被淘汰的节点,重新连接链表。
这种方法的时间复杂度为O(n*m),其中n为人数,m为报数的次数。
除了链表,还有其他数据结构可以用来解决约瑟夫环问题。
数据结构实验报告约瑟夫环约瑟夫环是一种经典的数学问题,它源于古代传说中的故事。
根据传说,约瑟夫是一位犹太历史学家,他和他的朋友们被罗马军队包围在一个洞穴里。
为了避免被俘虏,他们决定自杀,但是他们决定以一个特殊的方式来做。
他们围成一个环,从一个人开始,每隔一个人就杀死一个,直到只剩下一个人。
约瑟夫是最后一个幸存者。
这个问题可以用数据结构来解决,其中最常用的方法是使用循环链表。
循环链表是一种特殊的链表,它的最后一个节点指向第一个节点,形成一个环。
在解决约瑟夫环问题时,我们可以使用循环链表来模拟这个环。
首先,我们需要创建一个循环链表,并将所有的人依次添加到链表中。
然后,我们需要设置一个计数器,用来记录当前的位置。
接下来,我们需要遍历链表,每次遍历到计数器所指向的位置时,将该节点从链表中删除,并将计数器加一。
当计数器的值等于要删除的位置时,我们就将该节点删除,并将计数器重置为1。
重复这个过程,直到链表中只剩下一个节点为止。
通过使用循环链表,我们可以很方便地解决约瑟夫环问题。
这种方法的时间复杂度为O(n*m),其中n表示初始链表的长度,m表示要删除的位置。
由于每次删除一个节点后,链表的长度会减少,所以实际上的时间复杂度会小于O(n*m)。
除了使用循环链表,还可以使用数组来解决约瑟夫环问题。
我们可以创建一个长度为n的数组,然后将所有的人依次添加到数组中。
接下来,我们需要设置一个计数器,用来记录当前的位置。
然后,我们需要遍历数组,每次遍历到计数器所指向的位置时,将该人从数组中删除,并将计数器加一。
当计数器的值等于要删除的位置时,我们就将该人删除,并将计数器重置为1。
重复这个过程,直到数组中只剩下一个人为止。
与循环链表相比,使用数组解决约瑟夫环问题的方法更加简单。
但是,数组的长度是固定的,所以如果要解决的问题规模很大,可能会导致内存的浪费。
此外,数组的删除操作需要移动其他元素,所以时间复杂度较高。
综上所述,约瑟夫环问题是一个经典的数学问题,可以通过使用循环链表或数组来解决。
数据结构实验报告约瑟夫环约瑟夫环是一个经典的问题,涉及到数据结构中的循环链表。
在本次数据结构实验中,我们将学习如何使用循环链表来解决约瑟夫环问题。
约瑟夫环问题最早出现在古代,传说中的犹太历史学家约瑟夫斯·弗拉维奥(Josephus Flavius)在围攻耶路撒冷时,为了避免被罗马人俘虏,与其他39名犹太人躲进一个洞穴中。
他们决定宁愿自杀,也不愿被敌人俘虏。
于是,他们排成一个圆圈,从第一个人开始,每次数到第七个人,就将他杀死。
最后剩下的人将获得自由。
在这个问题中,我们需要实现一个循环链表,其中每个节点表示一个人。
我们可以使用一个整数来表示每个人的编号。
首先,我们需要创建一个循环链表,并将所有人的编号依次添加到链表中。
接下来,我们需要使用一个循环来模拟每次数到第七个人的过程。
我们可以使用一个指针来指向当前节点,然后将指针移动到下一个节点,直到数到第七个人为止。
一旦数到第七个人,我们就将该节点从链表中删除,并记录下该节点的编号。
然后,我们继续从下一个节点开始数数,直到只剩下一个节点为止。
在实现这个算法时,我们可以使用一个循环链表的数据结构来表示约瑟夫环。
循环链表是一种特殊的链表,其中最后一个节点的指针指向第一个节点。
这样,我们就可以实现循环遍历链表的功能。
在实验中,我们可以使用C语言来实现循环链表和约瑟夫环算法。
首先,我们需要定义一个节点结构体,其中包含一个整数字段用于存储编号,以及一个指针字段用于指向下一个节点。
然后,我们可以实现创建链表、添加节点、删除节点等基本操作。
接下来,我们可以编写一个函数来实现约瑟夫环算法。
该函数接受两个参数,分别是参与游戏的人数和每次数到第几个人。
在函数内部,我们可以创建一个循环链表,并将所有人的编号添加到链表中。
然后,我们可以使用一个循环来模拟每次数到第几个人的过程,直到只剩下一个节点为止。
在每次数到第几个人时,我们可以删除该节点,并记录下其编号。
最后,我们可以返回最后剩下的节点的编号。
约瑟夫环问题的两种解法(详解)约瑟夫环问题的两种解法(详解)题⽬: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。
循环队列之约瑟夫环问题约瑟夫问题 约瑟夫环(约瑟夫问题)是⼀个数学的应⽤问题:已知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;}。
约瑟夫环问题详解很久以前,有个叫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 problem)是一个非常经典的数学问题,其得名于公元1世纪的犹太历史学家约塞夫斯(Josephus)。
约瑟夫环问题描述如下:n个人围坐成一个圆圈,从一些人开始依次报数,每报到第m个人,该人就被淘汰出圆圈,然后从下一个人重新开始报数。
直到剩下最后一个人时,即为问题的解。
例如,当n=7,m=3时,最后剩下的是4号人。
本次实验的目的是研究约瑟夫环问题的解决方法,并通过编程实现给定n和m的情况下找到最后的获胜者。
首先,我们需要分析问题的特点。
当n=1时,该问题的解即为最后剩下的人;当n>1时,最后剩下的人可以通过前一轮问题的解(剩下n-1个人的情况下)推导出来。
我们可以将解决该问题的方法分为两种:递归法和迭代法。
一、递归法递归法是通过问题的子问题来解决原问题。
对于约瑟夫环问题来说,递归法的解题思路如下:1.当n=1时,问题的解即为1;2.当n>1时,问题的解为(找到n-1个人时的解+m-1)对n取模,即((f(n-1,m)+m-1)%n)+1二、迭代法迭代法通过循环来解决问题,不断更新当前的解,直到问题得到解决。
对于约瑟夫环问题来说,迭代法的解题思路如下:1.初始化一个长度为n的数组a,a[i]=1表示第i个人还在圆圈中,a[i]=0表示第i个人已经被淘汰出圆圈;2. 从第一个人开始计数,每报数到第m个人,则将该人设为已淘汰,并计数器count加1;3. 重复步骤2,直到count=n-1;4.循环遍历数组a,找到最后剩下的人。
为了更加直观地展示实验结果,我们通过Python编写下述代码:```python#递归法解决约瑟夫环问题def josephus_recursive(n, m):if n == 1:return 1else:return (josephus_recursive(n - 1, m) + m - 1) % n + 1#迭代法解决约瑟夫环问题def josephus_iterative(n, m):a=[1]*ncount = 0i=0while count < n - 1:if a[i] == 1:j=0while j < m:if a[(i + j) % n] == 1:j+=1else:j=0i=(i+1)%na[(i-1)%n]=0count += 1for i in range(n):if a[i] == 1:return i + 1#测试递归法解决约瑟夫环问题print(josephus_recursive(7, 3)) # 输出4 #测试迭代法解决约瑟夫环问题print(josephus_iterative(7, 3)) # 输出4 ```通过以上代码,我们可以得到n=7,m=3时,最后剩下的人是4号人。
约瑟夫问题(数学解法及数组模拟)约瑟夫问题(有时也称为约瑟夫斯置换,是一个出现在计算机科学和数学中的问题。
在计算机编程的算法中,类似问题又称为约瑟夫环。
又称“丢手绢问题”.)据说著名犹太历史学家 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.约瑟夫环(Joseph)问题的一种描述是:设有编号1,2,3。
n(n>0)的N个人围成一个圈,每个人持有一个密码(正整数)。
开始时任选一个正整数作为报数上限值m,从第一个人按顺时针方向自1开始顺序报数,报到m的人出圈,将他的密码作为新的m值,从他在顺时针方向上的下一个人开始重新从1报数,如此下去,直至所有人全部出列为止。
试设计一个程序求出出列顺序。
2.演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”之后,有用户在键盘上输入演示程序中规定的运算命令,相应的输入数据和运算结果显示在其后。
3.测试数据(1)m=20, n=7, 7个人的密码依次为:3,1,7,2,4,8,4结果:6,1,4,7,2,3,5二、概要设计本程序是多文件程序,构成的函数有int main() 主函数,输出出队序列int initsuiji() 随机数产生初始化int suiji(int x,int y) 随机数产生函数int InitList(SqList &L) 初始化顺序表int ListInsert(SqList &L,int i,ElemType e) 在顺序表中插入元素int ListDelete(SqList &L,int i,ElemType &e) 删除顺序表中的元素int shunxu(int number) 顺序存储算法JosephuNode *Creat_Node(int numbers) 创建单循环链表void Josephu(JosephuNode *head,int Password) 添加元素信息int lianbiao(int number) 链表算法其中,void main()是最主要的函数,分别执行两种算法,并在执行的同时按照出列顺序输出元素信息(编号,密码),并在结尾输出两种算法执行所用的时间长短。
三、详细设计#include<stdio.h>#include<malloc.h>typedef struct node{int num,code;struct node *next;}Lnode, *LinkList;Lnode *Create_L(LinkList L,int n){int i,key;Lnode *p,*s;p = L;for(i = 1;i <= n;i ++){printf("输入第%d人",i);printf(" 密码:");scanf("%d",&key);s = (Lnode *)malloc(sizeof(Lnode));p->next = s;p = s;p->num = i;p->code = key;}p->next = L->next;p = L;L = L->next;free(p);return L;}void Output_L(LinkList L,int m, int n) {int i,j,key;Lnode *p,*s;key = m;do{p = L;j = 1;if(key == 1){i = p->num;key = p->code;printf("第%d人",i);s = p->next;while(s->next != L)s = s->next;s->next = p->next;L = p->next;free(p);n --;}else{while(j < key){s = p;p = p->next;j ++;}i = p->num;key = p->code;printf("第%d人",i);s->next = p->next;L = p->next;free(p);n --;}}while(n > 0);}int main(){int n,m;Lnode *L;L = (Lnode *)malloc(sizeof(Lnode));printf("输入参加的人数:");scanf("%d",&n);if(n < 0){printf("输入数据不合理,请重新输入。
详解约瑟夫环问题及其相关的C语⾔算法实现约瑟夫环问题N个⼈围成⼀圈顺序编号,从1号开始按1、2、3......顺序报数,报p者退出圈外,其余的⼈再从1、2、3开始报数,报p的⼈再退出圈外,以此类推。
请按退出顺序输出每个退出⼈的原序号算法思想⽤数学归纳法递推。
⽆论是⽤链表实现还是⽤数组实现都有⼀个共同点:要模拟整个游戏过程,不仅程序写起来⽐较烦,⽽且时间复杂度⾼达O(nm),若nm⾮常⼤,⽆法在短时间内计算出结果。
我们注意到原问题仅仅是要求出最后的胜利者的序号,⽽不是要读者模拟整个过程。
因此如果要追求效率,就要打破常规,实施⼀点数学策略。
为了讨论⽅便,先把问题稍微改变⼀下,并不影响原意:问题描述:n个⼈(编号0~(n-1)),从0开始报数,报到(m-1)的退出,剩下的⼈继续从0开始报数。
求胜利者的编号。
我们知道第⼀个⼈(编号⼀定是m%n-1) 出列之后,剩下的n-1个⼈组成了⼀个新的约瑟夫环(以编号为k=m%n的⼈开始):k k+1 k+2 ... n-2, n-1, 0, 1, 2, ... k-2并且从k开始报0。
现在我们把他们的编号做⼀下转换:k --> 0k+1 --> 1k+2 --> 2......k-2 --> n-2k-1 --> n-1变换后就完完全全成为了(n-1)个⼈报数的⼦问题,假如我们知道这个⼦问题的解:例如x是最终的胜利者,那么根据上⾯这个表把这个x变回去不刚好就是n个⼈情况的解吗变回去的公式很简单,相信⼤家都可以推出来:x'=(x+k)%n如何知道(n-1)个⼈报数的问题的解?对,只要知道(n-2)个⼈的解就⾏了。
(n-2)个⼈的解呢?当然是先求(n-3)的情况——这显然就是⼀个倒推问题!好了,思路出来了,下⾯写递推公式:令f[i]表⽰i个⼈玩游戏报m退出最后胜利者的编号,最后的结果⾃然是f[n]递推公式f[1]=0;f[i]=(f[i-1]+m)%i; (i>1)实现⽅法⼀、循环链表建⽴⼀个有N个元素的循环链表,然后从链表头开始遍历并计数,如果基数i == m,则踢出该元素,继续循环,直到当前元素与下⼀个元素相同时退出循环#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct lnode{int pos;struct lnode *next;} lnode;/*** 构建循环链表&&循环遍历*/void create_ring(lnode **root, int loc, int n){lnode *pre, *current, *new;current = *root;pre = NULL;while (current != NULL) {pre = current;current = current->next;}new = (lnode *)malloc(sizeof(lnode));new->pos = loc;new->next = current;if (pre == NULL) {*root = new;} else {pre->next = new;}// 循环链表if (loc == n) {new->next = *root;}}/*** 约瑟夫环*/void kickoff_ring(lnode *head, int p){int i;lnode *pre, *pcur;pre = pcur = head;while (pcur->next != pcur) {for (i = 1; i < p; i ++) {pre = pcur;pcur = pcur->next;}printf("%d ", pcur->pos);pre->next = pcur->next;free(pcur);pcur = pre->next;}printf("%d\n", pcur->pos);free(pcur);}void print_ring(lnode *head){lnode *cur;cur = head;while (cur->next != head) {printf("%d ", cur->pos);cur = cur->next;}printf("%d\n", cur->pos);}int main(){int i, p, n;lnode *head;while (scanf("%d %d", &n, &p) != EOF) { // 构建循环链表for (i = 1, head = NULL; i <= n; i ++) create_ring(&head, i, n);// 约瑟夫环if (p != 1)kickoff_ring(head, p);elseprint_ring(head);}return 0;}/************************************************************** Problem: 1188User: wangzhengyiLanguage: CResult: AcceptedTime:110 msMemory:912 kb****************************************************************/⼆、数组模拟思想跟循环链表类似,少了构建循环链表的过程#include <stdio.h>#include <stdlib.h>int main(){int i, index, p, n, remain, delete[3001], flag[3001] = {0};while (scanf("%d %d", &n, &p) != EOF) {remain = n;index = 0;while (remain >= 1) {for (i = 0; i < n; i ++) {if (flag[i] == 0) {// 报数index ++;// 报p者退出圈外if (index == p) {// 退出圈外flag[i] = 1;// 重新报数index = 0;delete[remain - 1] = i + 1;remain --;}}}}// 输出每个退出⼈的序号for (i = n - 1; i >= 0; i --) {if (i == 0) {printf("%d\n", delete[i]);} else {printf("%d ", delete[i]);}}}return 0;}三、数学推导#include <stdio.h>int main(void){int i, n, m, last;while (scanf("%d", &n) != EOF && n != 0) {// 接收报数scanf("%d", &m);// 约瑟夫环问题for (i = 2, last = 0; i <= n; i ++) { last = (last + m) % i;}printf("%d\n", last + 1);}return 0;}。
约瑟夫环问题的两种解法(循环链表和公式法)问题描述这⾥是数据结构课堂上的描述: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),显然,这不是⼀个好的算法。
最新实验一约瑟夫问题实验报告实验目的:探究约瑟夫问题(Josephus Problem)的数学规律及其在不同参数下的表现,验证相关算法的效率和准确性。
实验背景:约瑟夫问题是一个著名的理论问题,源自于罗马时代的一个传说。
问题可以描述为:n个人围成一圈,从第一个人开始报数,每数到第m个人,该人出圈,然后从下一个人重新开始报数,如此循环,直到所有人出圈。
本实验旨在通过编程模拟这一过程,并分析结果。
实验方法:1. 采用编程语言(如Python)编写约瑟夫问题的模拟程序。
2. 设定不同的n和m值,运行程序,记录每个人的出圈顺序及最后剩下的人的位置。
3. 分析不同n和m值下的出圈顺序规律。
4. 对比不同算法(如递归法、迭代法)的运行时间,评估效率。
实验步骤:1. 初始化参数:确定模拟的总人数n和报数间隔m。
2. 创建一个循环队列模拟人们围成的圈。
3. 通过循环和条件判断模拟报数和出圈过程。
4. 记录每次出圈的人的编号和最终剩下的人的位置。
5. 改变n和m的值,重复步骤1至4,收集多组数据。
6. 分析数据,寻找出圈规律。
7. 对模拟过程进行计时,比较不同算法的运行时间。
实验结果:1. 通过大量实验数据,发现当n和m的值较小时,可以直观看出出圈顺序的规律。
2. 随着n和m值的增大,出圈顺序变得更加复杂,但依然存在一定的规律性。
3. 实验中使用的迭代法在处理大规模数据时,相比递归法具有更高的效率,递归法在深度较大时可能会导致栈溢出。
4. 通过图表展示了不同n和m值下,最后剩下的人的位置的概率分布。
实验结论:1. 约瑟夫问题的出圈顺序并非完全随机,存在一定的数学规律。
2. 迭代法在解决大规模约瑟夫问题时更为高效和稳定。
3. 本实验为进一步研究约瑟夫问题提供了实验数据和算法优化方向。
建议:对于未来的研究,可以尝试将约瑟夫问题推广到更多变种,如双向报数、不同方向报数等,以及探索其在实际问题中的应用,如网络协议设计、资源分配等。
约瑟夫问题数据结构实验报告[正文]1.实验目的本实验的目的是分析约瑟夫问题,并设计合适的数据结构解决该问题。
2.实验背景约瑟夫问题,又称为约瑟夫环,是一个经典的数学问题。
问题描述如下:有n个人围成一圈,从第一个人开始报数,数到第m个人时将其杀死,然后从下一个人开始重新报数,数到第m个人又将其杀死,如此循环进行,直到所有人都被杀死为止。
求出最后一个被杀的人在初始序列中的编号。
3.实验设计为了解决约瑟夫问题,我们需要设计合适的数据结构来表示这个过程。
以下为实验所采用的数据结构:3.1 线性表由于约瑟夫问题是围成一圈的,因此我们选择使用循环链表来表示人围成的圈。
每个节点代表一个人,包含一个成员变量用于存储人的编号。
3.2 算法采用如下算法来解决约瑟夫问题:1.创建一个循环链表,将n个人的编号分别存入节点中。
2.初始化一个指针p指向链表的第一个节点。
3.从第一个人开始报数,每报到第m个人,将该节点从链表中删除。
4.如果链表中只剩下一个节点,此时的节点即为最后一个被杀的人,输出其编号。
4.实验步骤4.1 数据结构设计根据实验设计中的描述,我们编写了一个含有循环链表和节点的数据结构。
```cppstruct ListNode {int number;ListNode next;};```4.2 实现约瑟夫问题算法根据实验设计中的算法描述,我们编写了解决约瑟夫问题的函数。
```cppint josephusProblem(int n, int m) {// 创建循环链表// 初始化指针p// 开始报数并删除节点// 返回最后被杀的人的编号}```4.3 测试与分析我们通过输入不同的n和m值,测试了约瑟夫问题的解决函数,并对实验结果进行了分析。
5.实验结果经过测试,我们得到了约瑟夫问题的解。
6.实验总结通过本实验,我们深入了解了约瑟夫问题,并成功设计了合适的数据结构和算法解决了该问题。
附件本文档无附件。
法律名词及注释1.约瑟夫问题:亦称为约瑟夫环问题,是一个数学难题,起源于古代历史记载,已有几个世纪的历史。
数据结构期末试验报告学院:专业:学号:班级:姓名:2010.12.12 Joseph约瑟夫环上机实验报告实验名称:joseph约瑟夫环题目要求的约瑟夫环操作:编号是1,2,……,n的n个人按照顺时针方向围坐一圈,每个人只有一个密码(正整数)。
一开始任选一个正整数作为报数上限值m,从第一个仍开始顺时针方向自1开始顺序报数,报到m时停止报数。
报m的人出列,将他的密码作为新的m值,从他在顺时针方向的下一个人开始重新从1报数,如此下去,直到所有人全部出列为止。
设计一个程序来求出出列顺序。
实验要求:1~)利用单向循环链表存储结构模拟此过程,按照出列的顺序输出各个人的编号。
2~)建立输入处理输入数据,输入m的初值,n ,输入每个人的密码,建立单循环链表。
3~)建立一个输出函数,将正确的输出序列4~)测试数据:m的初值为20,n=7 ,7个人的密码依次为3,1,7,2,4,7,4,首先m=6,则正确的输出是什么?实验过程:1.基本算法以及分析:本程序主要是以建立单循环链表的形式,建立起一个约瑟夫环,然后根据之前创立的结点,输入结点里的一些数据,如下typedef struct Node{int Index; 在当前环中所处的位置,即编号int Password; 在当前环中的所带的密码struct Node *next;}JosephuNode;程序有主函数开始,首先,提示输入创建约瑟夫环环数以及每个环上所带的密码。
然后,开始调用JosephuNode *Creat_Node函数,利用单循环链表建立起约瑟夫环,tail->next = head;就是将最后一个结点的后继指向头结点,函数结尾 return head; 将约瑟夫环的头指针返回,并将它赋值head,然后主函数继续调用Josephu函数,通过讲head和Password引入函数,以建立两个嵌套循环输出并实现如下功能:编号是1,2,……,n的n个人按照顺时针方向围坐一圈,每个人只有一个密码(正整数)。
约瑟夫环问题可视化public class Person {int no;Person(int no){this.no=no;}Person(){no=0;}}public class PersonNode{Person item;PersonNode next;PersonNode(){item=null;next=null;}PersonNode(Person item){this.item=item;next=null;}}public class PersonList{PersonNode [] data;int size;PersonList(){data=new PersonNode[1];size=0;}boolean isEmpty(){return size==0;}private boolean isFull(){return size==data.length;}PersonNode get(int index){return data[index-1];}void set(int index,PersonNode target){data[index-1]=target;}void add(PersonNode target){if(this.isFull())this.stretch();data[size]=target;if(size>0){data[size-1].next=data[size];data[size].next=data[0];}size++;}private void stretch(){PersonNode newData[]=new PersonNode[data.length*2]; for(int i=0;i<data.length;i++)newData[i]=data[i];data=newData;}PersonNode remove(int index){PersonNode result=data[index];int t=this.find(result.next);for(int i=t+1;i<size;i++)data[i-1]=data[i];result.next=result.next.next;size--;return result;}int find(PersonNode p){for(int i=0;i<size;i++)if(data[i].equals(p))return i;return 0;}}public class Personqueue{Person[] persons;int size;int front;Personqueue(){persons=new Person[1];size=0;front=0;}private boolean isFull(){return size==persons.length;}private void stretch(){Person[] newpersons=new Person[persons.length*2]; for(int i=0;i<persons.length;i++)newpersons[i]=persons[(front+i)%persons.length]; persons=newpersons;front=0;}boolean isEmpty(){return size==0;}void add(Person p){if(this.isFull())this.stretch();persons[(front+size)%persons.length]=p;size++;}Person remove(){Person result=persons[front];front=(front+1)%persons.length;size--;return result;}}public class Method {public int intinput(String str) throws NumberFormatException {int i=Integer.parseInt(str);return i;}private boolean between(int n,int min,int max){for(int i=min;i<=max;i++)if(n==i)return true;return false;}public boolean isValid(String str){int m=0;try{m=this.intinput(str);}catch(NumberFormatException e){return false;}if(!this.between(m, 1, 100)){return false;}return true;}public String Joseph(int m,int n){Personqueue queue=new Personqueue();PersonList list=new PersonList();for(int i=1;i<=n;i++){Person p=new Person(i);PersonNode personnode=new PersonNode(p);list.add(personnode);queue.add(p);}PersonNode p=list.get(list.size);String result="";result+="链表结构:\n";while(!list.isEmpty()){for(int i=1;i<m;i++)p=p.next;result+=p.next.item.no+" ";list.remove(list.find(p));}result+="\n顺序表结构:\n"; while(!queue.isEmpty()){for(int count=0;count<m-1;count++) queue.add(queue.remove());result+=queue.remove().no+" ";}return result;}}import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.swt.SWT;import org.eclipse.swt.widgets.Display;import org.eclipse.swt.widgets.Shell;import org.eclipse.swt.widgets.Text;import bel;import org.eclipse.wb.swt.SWTResourceManager; import org.eclipse.swt.widgets.Button;import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.events.TraverseListener; import org.eclipse.swt.events.TraverseEvent;public class MainShell extends Shell {private Text text;private Text text_1;private Text text_2;/*** Launch the application.* @param args*/public static void main(String args[]) {try {Display display = Display.getDefault();MainShell shell = new MainShell(display);shell.open();yout();while (!shell.isDisposed()) {if (!display.readAndDispatch()) {display.sleep();}}} catch (Exception e) {e.printStackTrace();}}/*** Create the shell.* @param display*/public MainShell(Display display) {super(display, SWT.SHELL_TRIM);text = new Text(this, SWT.BORDER);text.addTraverseListener(new TraverseListener() {public void keyTraversed(TraverseEvent e) {if(e.keyCode==SWT.CR){e.detail=SWT.TRAVERSE_TAB_NEXT;e.doit=true;text_1.selectAll();}}});text.setBounds(50, 62, 113, 21);Label lblNewLabel = new Label(this, SWT.NONE);lblNewLabel.setFont(SWTResourceManager.getFont("Segoe UI", 12, SWT.BOLD)); lblNewLabel.setAlignment(SWT.CENTER);lblNewLabel.setBounds(50, 24, 113, 26);lblNewLabel.setText("\u603B\u4EBA\u6570");text_1 = new Text(this, SWT.BORDER);text_1.addSelectionListener(new SelectionAdapter() {@Overridepublic void widgetDefaultSelected(SelectionEvent e) {int m=0,n=0;Method method=new Method();String str1=text.getText().trim();String str2=text_1.getText().trim();if(!str1.equals("")&&!str2.equals("")){if(!method.isValid(str1)||!method.isValid(str2))MessageDialog.openWarning(getShell(), "输入错误", "输入错误!请重新输入!");else{n=method.intinput(str1);m=method.intinput(str2);text_2.setText(method.Joseph(m, n));}}text.selectAll();text.forceFocus();}});text_1.setBounds(237, 62, 113, 21);Label lblNewLabel_1 = new Label(this, SWT.NONE);lblNewLabel_1.setFont(SWTResourceManager.getFont("Segoe UI", 13, SWT.BOLD));lblNewLabel_1.setAlignment(SWT.CENTER);lblNewLabel_1.setBounds(237, 24, 113, 26);lblNewLabel_1.setText("\u6240\u62A5\u6570\u5B57");text_2 = new Text(this, SWT.BORDER | SWT.WRAP | SWT.V_SCROLL | SWT.MULTI);text_2.setEditable(false);text_2.setBounds(10, 132, 410, 126);Button button = new Button(this, SWT.NONE);button.addSelectionListener(new SelectionAdapter() {@Overridepublic void widgetSelected(SelectionEvent e) {int m=0,n=0;Method method=new Method();String str1=text.getText().trim();String str2=text_1.getText().trim();if(!str1.equals("")&&!str2.equals("")){if(!method.isValid(str1)||!method.isValid(str2))MessageDialog.openWarning(getShell(), "输入错误", "输入错误!请重新输入!");else{n=method.intinput(str1);m=method.intinput(str2);text_2.setText(method.Joseph(m, n));}}text.selectAll();text.forceFocus();}});button.setBounds(161, 101, 75, 25);button.setText("\u786E\u5B9A");createContents();}/*** Create contents of the shell.*/protected void createContents() {setText("\u7EA6\u745F\u592B\u73AF\u53EF\u89C6\u5316");setSize(450, 300);}@Overrideprotected void checkSubclass() {// Disable the check that prevents subclassing of SWT components}}。