猴子选大王算法

合集下载

猴子选大王

猴子选大王

[题目]第1.1猴子选大王问题一:实验内容:M只猴子要选大王,选举办法如下:所有猴子按1,2……n编号围成一圈,从第一号开始顺序1,2……m,凡是报m号的退出圈外,如此循环报数直到圈内只剩一只猴子时这只猴子就是大王。

二:实验要求:利用单向循环链表模拟此过程,输出选出的大王编号。

三:程序的设计思想:(1)问题分析:“猴子选大王”问题是约瑟夫环问题的一个特例。

由于本题目的数据元素个数不可知,所以可使用链表来动态的分配内存空间。

而该问题又是一个不断的循环问题所以用循环链表来实现。

(2)总体设计:首先生成一个空链表,并给n个结点分配空间,让单链表的表尾指针指向头结点则生成一个带有n个结点的循环单链表。

再给每只猴子建立顺序的编号。

现从第一个结点开始报数,依次顺序查找出报数为m的待出列的结点(猴子)通过q->next=p->next删除该结点后继续运行否则让q成为p的前驱指针。

最后当p->next==p时停止运行,得到p所指向的结点即为猴子选出大王的编号。

四:提供测试结果:定义 n=8, m=3,测试结果如下:对猴子进行编号!1号猴子:12号猴子:23号猴子:34号猴子:45号猴子:56号猴子:67号猴子:78号猴子:82号猴子报:2 3号猴子报:3 3号猴被淘汰4号猴子报:1 5号猴子报:2 6号猴子报:3 6号猴被淘汰7号猴子报:1 8号猴子报:2 1号猴子报:3 1号猴被淘汰2号猴子报:1 4号猴子报:2 5号猴子报:3 5号猴被淘汰7号猴子报:1 8号猴子报:2 2号猴子报:3 2号猴被淘汰4号猴子报:1 7号猴子报:2 8号猴子报:3 8号猴被淘汰7号猴子报:24号猴子报:34号猴被淘汰7号猴子报:1胜出:7号猴子Press any key to continue五:程序源代码#include <stdio.h>#include <stdlib.h>#define n 8#define m 3typedef struct monkey{int num;struct monkey *next;} Monkey;int main(){Monkey *p,*head,*q;int i;head=p=q=malloc(sizeof(Monkey));//建立头指针 for(i=1;i<n;i++) //给n个结点分配空间{p=malloc(sizeof(Monkey));q=p;}q->next=head; //建立循环链表p=head;printf("对猴子进行编号!\n");for(i=1;i<=n;i++) //给n只猴子分别建立顺序编号{p->num=i;printf("%d号猴子:%d\n",p->num,p->num);p=p->next;}i=0; //初始化p=head;while(1){i++;printf("%d号猴子报:%d\n",p->num,i);if(p->next==p) break; //判断还剩下最后一个结点时停止运行 if(i==m) //报道m的猴子淘汰{i=0;printf("%d号猴被淘汰\n",p->num);q->next=p->next;continue;}else{if(i==m-1) q=p;p=p->next;}}printf("胜出:%d号猴子",p->num); }。

猴子选大王——精选推荐

猴子选大王——精选推荐

猴子选大王【问题】n只猴子选大王,选举办法如下:从头到尾1,2,3报数,凡报3的退出,余下的从尾到头1,2,3报数,凡报3的退出...如此类推,当剩下两只猴子时,取这时报1的为王,若想当猴王,请问当初应占据什么位置?【测试数据】【参考程序1】const number=3;var n,num,i,total:integer;a:array[1..100]of boolean; order:boolean;beginwriteln('input n:');readln(n);total:=n; {队伍中剩下的猴子数}for i:=1 to n do a[i]:=true;repeatorder:=true; {order=true:顺序报数} num:=0; {num:报的数字}for i:=1 to n do {顺序报数}if a[i] then begin {第i只在队列中才有资格报数}num:=num+1;if (num=number) then begin {如果为3} a[i]:=false;total:=total-1; {出队,且猴子数少1}num:=0; {num置0,又准备从1报起}end;end; {报到尾}if total>number-1 then order:=false; {如还要继续报,则从尾到头}num:=0; {从尾到头时,order=false}for i:=n downto 1 do {逆向报数}if a[i] then begin {在队列中}num:=num+1;if (num=number) then begina[i]:=false;total:=total-1;num:=0;end;end;until total=number-1; {直到剩下2只}if not order then for i:=1 to n do if a[i] then begin {报剩2只时,如上一次为从尾到头报数,则猴王为从头到尾报的第一只}writeln('The Monkey King is :',i);readln;halt;end;if order then for i:=n downto 1 do if a[i] then begin {报剩2只时,如上一次为从头到尾报数,则猴王为从尾到头报的第一只}writeln('The Monkey King is :',i);readln;halt;end;end.【参考程序2】程序1中,用了order来记录是顺序还是逆序报数,不太方便。

蓝桥杯-猴子选大王(约瑟夫问题)

蓝桥杯-猴子选大王(约瑟夫问题)

蓝桥杯-猴⼦选⼤王(约瑟夫问题)标题:猴⼦选⼤王⼀群猴⼦要选新猴王。

新猴王的选择⽅法是:让N只候选猴⼦围成⼀圈,从某位置起顺序编号为1~N号。

从第1号开始报数,每轮从1报到3,凡报到3的猴⼦即退出圈⼦,接着⼜从紧邻的下⼀只猴⼦开始同样的报数。

如此不断循环,最后剩下的⼀只猴⼦就选为猴王。

请问是原来第⼏号猴⼦当选猴王?输⼊格式:输⼊在⼀⾏中给⼀个正整数N(≤1000)。

输出格式:在⼀⾏中输出当选猴王的编号。

输⼊样例:11输出样例:7思路⼀:⽤数组模拟⼀个环,存储第下标+1位猴⼦是否退出(因为下标从0开始),数组初始化为0,每次轮到数3的猴⼦就将他的下标置为-1,最后⼀个下标不为-1的猴⼦就是选中的王。

1 #include<bits/stdc++.h>2using namespace std;34const int N = 1000; //共有N个猴⼦56int a[N]; //⽤数组和%操作模拟圈78int index = 0; //下标index9int i = 1; //⽤来对3计数10int counter; //记录每次剩下的猴⼦个数1112int main()13 {14int num; //num是猴⼦的数量15 cin >> num;16 counter = num;1718while(counter > 1)19 {20if(a[index] != -1) //当下标为index的猴⼦还在圈内时21 {22if(i == 3)23 {24 a[index] = -1; //将数到3的猴⼦退出圈⼦,将下标置为-125 counter--; //剩下的猴⼦总个数-126 }2728 i++;2930if(i > 3) //i=4时候,i要回到131 {32 i = i % 3;33 }34 }3536 index++;3738if(index >= num) //当下标达到了猴⼦总数时,要回到开头39 {40 index = index % num;41 }4243 }4445for(int i = 0; i < num; i++)46 {47if(a[i] != -1)48 {49 cout << i + 1; //数组下标是从0开始的,要+150 }51 }5253return0;54 }思路2:使⽤递归思想1 #include<bits/stdc++.h>2using namespace std;34int fun(int n)5 {6if(1 == n)7 {8return0;9 }1011return (fun(n - 1) + 3) % n;12 }1314int main()15 {16int n;17 cin >> n;18 cout << fun(n) + 1;19return0;20 }。

约瑟夫问题

约瑟夫问题

4、狐狸捉兔子
题目:
围绕着山顶有10个洞,狐狸要吃兔子,兔子说:“可以,但必须找到我,我就藏身于这十个洞中,你从10号洞出发,先到1号洞找,第二次隔1个洞找,第三次隔2个洞找,以后如此类推,次数不限。”但狐狸从早到晚进进出出了1000次,仍没有找到兔子。问兔子究竟藏在哪个洞里?
参考程序下载
--------------------------------------------------------------------------------
5、进制转换
题目:
将一个十进制自然数转换成二进制数,一般采取除2取余法。从键盘输入一个十进制自然数(约定该数小于等于Maxlongint),输出相应的二进制数
设有一天平,可用来称物体的质量,同时给出一个正整数n(n<=10)。
问题1:试设计n个砝码的质量,用它们能称出尽可能多的1,2,3,...连续整数质量,约定砝码可以放在天平的左右两个托盘中的任何一个或两个中。例如n=2,此时设计2个砝码的质量分别为1,3,则能同时称取1,2,3,4。
问题2:在给出n个砝码能称出最大质量范围内的一个质量x,试给出称取x的方案。如上例中:
6/7,7/8,1/1
编程求出n级法雷序列,每行输出10个分数。n的值从键盘输入。
--------------------------------------------------------------------------------
13、砝码设计
题目:
①把组成这个四位数的4个数字由小到大排列,形成由这四个数字组成的最大的四位数;
②把组成这个四位数的4个数字由大到小排列,形成由这四个数字组成的最小的四位数(如果含有数字0,则不足四位);

约瑟夫问题大全

约瑟夫问题大全

“约瑟夫”问题及若干变种林厚从例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),对于极限数据会超时。

第20章猴子选大王游戏

第20章猴子选大王游戏
➢ 在本章,我们以此问题作为研究对象, 通过编写程序,来输出站成一圈猴子的 出圈顺序号。
20.2 问题分析及实现
➢ 20.2.1 问题分析 ➢ 20.2.2 问题实现 ➢ 20.2.3 程序运行
20.2 问题分析及实现
➢ 拿到这个算法问题,首先想到的前面提到的 要领:看清、想明、把握每一个细节。
猴子选大王游戏
➢ 猴子选大王(亚瑟夫环)是数据结构和算法 中常见的一类问题。有人使用循环队列实现, 有人使用链表实现。本章将使用数组的回溯 算法实现选猴王的算法程序。
20.1 问题描述
➢ 有M只猴子围成一圈,每只各一个从1 到M中的编号,打算从中选出一个大王; 经过协商,决定出选大王的规则:从第 一个开始循环报数,数到N的猴子出圈, 最后剩下来的就是大王。
11
printf("%d ",Monkey[i]); /*让猴子站成一圈*/
12 printf("\n");
13 }
20.2.2 问题实现
➢ 2. 将结果输出 ➢ 将回溯结果输出至屏幕,以循环打印的方式,
调用标准输入输出函数printf,将结果回显。 代码如下(代码20-2.txt)
20.2.2 问题实现
20.2.2 问题实现
➢ 本小节就通过编程来实现此问题,实现的代 码如下。
➢ 1. 让猴子站成一圈 ➢ 如何让猴子站成一圈呢?根据问题分析结n 果,
采用整型一n维数组中保存猴子顺序号n,即表 示站成一排。代码如下(代码20-1.txt)。
20.2.2 问题实现
01 #include<stdio.h>
第20章
猴子选大王游戏
问题描述 问题分析及实现 开发过程常见问题及解决

猴子选大王问题

猴子选大王问题

这是17世纪的法国数学家加斯帕在《数目的游戏问题》中讲的一个故事:15个教徒和15 个非教徒在深海上遇险,必须将一半的人投入海中,其余的人才能幸免于难,于是想了一个办法:30个人围成一圆圈,从第一个人开始依次报数,每数到第九个人就将他扔入大海,如此循环进行直到仅余15个人为止。

问怎样排法,才能使每次投入大海的都是非教徒。

*问题分析与算法设计约瑟夫问题并不难,但求解的方法很多;题目的变化形式也很多。

这里给出一种实现方法。

题目中30个人围成一圈,因而启发我们用一个循环的链来表示。

可以使用结构数组来构成一个循环链。

结构中有两个成员,其一为指向下一个人的指针,以构成环形的链;其二为该人是否被扔下海的标记,为1表示还在船上。

从第一个人开始对还未扔下海的人进行计数,每数到9时,将结构中的标记改为0,表示该人已被扔下海了。

这样循环计数直到有15个人被扔下海为止。

[编辑本段] 约瑟夫问题的一般形式:约瑟夫问题是个有名的问题:N个人围成一圈,从第一个开始报数,第M个将被杀掉,最后剩下一个,其余人都将被杀掉。

例如N=6,M=5,被杀掉的人的序号为5,4,6,2,3。

最后剩下1号。

假定在圈子里前K个为好人,后K个为坏人,你的任务是确定这样的最少M,使得所有的坏人在第一个好人之前被杀掉。

C++代码示例: #i n c l u d e<i o s t r e a m>u s i n g n a m e s p a c e s t d;v o i d m a i n()i n t n,m,a[101],k,i,j,n um; //计数器是从1开始的,所以100个人用101 c o u t<<"请输入参加游戏的玩家人数(不超过100人):";c i n>>n;c o u t<<"----------------------------------------"<<e nd l;i f(n>100){c o u t<<"玩家太多,请重新登陆此程序!"<<e nd l;r e t u r n;}c o u t<<"输入游戏中要玩的数字:";c i n>>m;c o u t<<"----------------------------------------"<<e nd l;f o r(i=1;i<=n;i++){ a【i】=1;//注意百度百科里不让使用ASCII里的方括号,这里是中文字符集里的方括号,}j=0;k=0;f o r(i=1;i<=n+1;i++){i f(a【i】==1){j=j+a【i】;i f(j==m)j=0;a【i】=0;k++;}i f(k==n){n u m=i;b r e a k;}}i f(i==n+1)i=0;}c o u t<<"最后获胜的玩家是第"<<n u m<<"号玩家!"<<e nd l;c o u t<<"----------------------------------------"<<e nd l;}写完密码约瑟夫就想到原来看到约瑟夫问题的一个数学解法很巧妙很简单不过只能推出最后一个出列的人无论是用链表实现还是用数组实现都有一个共同点:要模拟整个游戏过程,不仅程序写起来比较烦,而且时间复杂度高达O(nm),当n,m非常大(例如上百万,上千万)的时候,几乎是没有办法在短时间内出结果的。

猴子选大王问题

猴子选大王问题

这是17世纪的法国数学家加斯帕在《数目的游戏问题》中讲的一个故事:15个教徒和15个非教徒在深海上遇险,必须将一半的人投入海中,其余的人才能幸免于难,于是想了一个办法:30个人围成一圆圈,从第一个人开始依次报数,每数到第九个人就将他扔入大海,如此循环进行直到仅余15个人为止。

问怎样排法,才能使每次投入大海的都是非教徒。

*问题分析与算法设计约瑟夫问题并不难,但求解的方法很多;题目的变化形式也很多。

这里给出一种实现方法。

题目中30个人围成一圈,因而启发我们用一个循环的链来表示。

可以使用结构数组来构成一个循环链。

结构中有两个成员,其一为指向下一个人的指针,以构成环形的链;其二为该人是否被扔下海的标记,为1表示还在船上。

从第一个人开始对还未扔下海的人进行计数,每数到9时,将结构中的标记改为0,表示该人已被扔下海了。

这样循环计数直到有15个人被扔下海为止。

[编辑本段]约瑟夫问题的一般形式:约瑟夫问题是个有名的问题:N个人围成一圈,从第一个开始报数,第M个将被杀掉,最后剩下一个,其余人都将被杀掉。

例如N=6,M=5,被杀掉的人的序号为5,4,6,2,3。

最后剩下1号。

假定在圈子里前K个为好人,后K个为坏人,你的任务是确定这样的最少M,使得所有的坏人在第一个好人之前被杀掉。

C++代码示例:#include<iostream>usingnamespacestd;voidmain(){intn,m,a[101],k,i,j,num;.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)modn 如何知道(n-1)个人报数的问题的解?对,只要知道(n-2)个人的解就行了。

猴子选大王

猴子选大王

一. 需求分析:猴子选大王是一个小游戏,其规则是:假设n个猴子围成一堆,取数字m为将要被淘汰的数字,从第一个猴子开始数,数到数字m时,则该猴子出列,被淘汰,然后从被淘汰的猴子的下一个开始数,再数到数字m时,这个猴子也被淘汰,从下一个开始数,依次进行,直到剩下一个猴子结束。

该猴子即猴子大王。

二. 概要设计:该程序没有抽象数据类型,主要用循环和数组实现,先用数组存放猴子,假定一个猴子的最大个数,再通过参数传递一个正确的猴子(将要做游戏的猴子数),先将猴子初始化为0,用一个计数器存countone存放剩余的猴子的个数,用sum存放数字,即从1到m 的数字,当countone>0时,进行循环,先将countone记为0,当循环等于m时,一次循环结束,否则countone加1,依次进行第二次的循环,直到剩下一个猴子为止,并记下当m!sum是的猴子,为幸运猴子大王。

三. 详细设计:int choose(int num,int del) //num表示猴子总数,del表示将要被淘汰的猴子总数{for(i=0;i<num;i++)a[i]=1; //猴子初始化,为1表示还有希望被选为大王while(countOne>1) //是否进行继续淘汰的判断,其中放剩余的猴子个数{countOne=0;for(i=0;i<num;i++){sum+=a[i];if(sum==del) //del同时也记录了每次数数的结束sum=a[i]=0; //淘汰倒霉猴子;countOne+=a[i]; //是和if相匹配语句,当判断条件不成立时执行}for(i=0;i<num;i++)if(a[i]!=0)return i; //找到幸运猴子编号(从0开始的);}void main(){int num,del;cout<<"请输入猴子总数和淘汰数字:";cin>>num>>del;cout<<"第"<<choose(num,del)+1<<"个猴子为王!"<<endl;}四.调试分析:输入猴子总个数,在输入将要淘汰的猴子的个数时,能正确输出所选的大王猴子,调试正确无误。

猴子选大王 课程设计报告

猴子选大王      课程设计报告

目录一、需求分析 (1)1、问题描述: (1)2、基本要求: (1)3、需求分析: (1)二、概要设计 (2)三、详细设计 (3)1、循环队列 (3)2、循环链表 (4)3、伪代码 (5)4、具体函数分析及变量分析 (6)四、调试分析和测试结果 (6)五、总结 (9)六、参考文献 (10)七、附录 (11)一、需求分析1、问题描述:一堆猴子都有编号,编号是1,2,3 ...m ,这群猴子(m个)按照1-m的顺序围坐一圈,从第1开始数,每数到第N个,该猴子就要离开此圈,这样依次下来,直到圈中只剩下最后一只猴子,则该猴子为大王。

2、基本要求:输入数据:输入m,n。

m,n 为整数,n<m。

输出形式:中文提示按照m个猴子,数n 个数的方法,输出为大王的猴子是几号,建立一个函数来实现此功能。

3、需求分析:①输入数据m,n②计算出最终猴子大王的序号。

③模拟出整个过程。

④找到合适的数据结构处理这个问题。

⑤找到正确的方法解决这个问题。

二、概要设计对题意进行分析后,可以画出整个过程的流程图。

具体流程图:这个问题属于约瑟夫环问题,我们对这个题目进行具体分析:假如现在m=5,n=2,即有5只猴子,按照循环数2的方法,我们演变这个过程:第一次:1 2 3 4 5× 2号出局第二次:1 2 3 4 5×× 4号出局第三次:1 2 3 4 5××× 1号出局第四次:1 2 3 4 5×××× 5号出局最后得到猴子大王的序号是3号。

那么一般化,对于m猴子,n只猴子我们该怎么做?三、详细设计1、循环队列队列是一种特殊的线性表,它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作。

进行插入操作的端称为队尾,进行删除操作的端称为队头。

队列中没有元素时,称为空队列。

仔细分析整个过程,我发现这个过程和学过的循环队列特别像,在学习循环队列的时候,如果采取数组来存储队列,那么在front端弹出元素就执行front=(front+1)%MAX,在rear端进入队列的时候就执行rear=(rear+1)%MAX,以实现绕圈的操作。

猴子算法

猴子算法

一、猴子选大王:(1)M只猴子要选大王,选举办法如下:所有猴子按1-M编号围坐一圈,从1号开始按顺序1,2,,,K报数,凡报到K的猴子退出到圈外,如此循环报数,直到圈内只剩下一只猴子时,这只猴子就是大王。

M和K由输入文件提供,要求在输出文件中打印出最后剩下的猴子的编号。

数据规模(M<=1000,K<=10)【输入文件】输入文件monkey.in 的第1 行,为两个正整数,用一个空格隔开:M K【输出文件】输出文件monkey.out 只有一个正整数,输出最后一个猴子的编号【输入样例】7 3【输出样例】4这就是顶顶有名的约瑟夫问题。

这是一个据说是由古罗马著名史学家Josephus提出的问题演变而来的。

称之为约瑟夫问题。

很多资料上对这一问题解释得过于繁杂,实现起来不好理解。

在这里介绍一下本人的一些想法以供大家参考。

这个题目其实就是一种编程的经验问题。

我们可以假设猴子就位的状态用1表示,把猴子离开的状态用0表示。

那么我们就可以用一个a[M]的数组来存放M个猴子是否就位的状态。

我们可以一边报数一边遍历该数组,每遇到第K个1时,就把当前位置的1变为0,表示当前位置的猴子已经出局了。

一直循环遍历到我们的状态数组只有一个1的时候,这个存放1的数组下标再加上1(因为数组下标是由0开始的,所以要加1)即为选出的大王的编号。

想法很简单,现在关键的问题是如何解决当报数到第M个猴子的时候如何使得下一个报数重新回到第1个猴子处,也就是如何使用一维数组来解决环型问题的求解技巧。

大家想一下当我们的猴子围成圈坐的时候,问题其实由简单的一维数组变成了首尾相接的环型数组,也就是我们数据结构中的环型队列。

假设p为当前数组某一元素的下标,对于一维数组来说,我们只要p++就可以移动到下一个元素的位置上。

那么当p=M时,如果我们直接使用p++的话,p的值就超出了a[M]数组的最大长度,我们想要的是p++之后等于0。

那么如何实现呢?解决环型数组循环遍历元素的方法:对于环型数组移动下标时,我们如果每次在p++之后再加上p=p%M的话就能解决先前遇到的越界的问题。

数据结构 猴子选大王

数据结构 猴子选大王

【完成题目1】猴子选大王【问题描述】一堆猴子都有编号,编号是1,2,3 ...m ,这群猴子(m个)按照1--m的顺序围坐一圈,从第1开始数,每数到第N个,该猴子就要离开此圈,这样依次下来,直到圈中只剩下最后一只猴子,则该猴子为大王。

【基本要求】输入数据:输入m,n。

m,n 为整数,n<m;输出形式:中文提示按照m个猴子,数n 个数的方法,输出为大王的猴子是几号,建立一个函数来实现此功能。

【算法设计】通过对“猴子选大王”问题的分析,由于本题目的数据元素的个数不可预知,所以使用链表。

链表是动态的,可以在需要的时候增长和减少其长度,而数组是在编译时分派内存的,事业其大小是不可改变的,而且会出现内存浪费的情况。

我认为单循环链表能较好,在建立循环链表时,因为链表的大小由输入决定,因此与匹配的结点数也是变化的,所以要进行动态内存分配。

注意:输入数据为整型,切勿输入整形以外数据类型,否则程序将报错。

#include <stdio.h>为包含的库函数Linklist Create(int n)// 创建循环链表 n为猴子总数int King(Linklist head,int n,int i)//选出大王来【源代码】#include <iostream>#include <stdlib.h>using namespace std;typedef struct node{int data;struct node *next;//定义结点指针}ListNode;typedef ListNode *Linklist;//自定义链表类型/Malloc 向系统申请分配指定size个字节的内存空间ListNode *q,*p;Linklist head=(Linklist)malloc(sizeof(ListNode));//申请头结点/*******按将猴子数量编号并存入链表*******/Linklist Create(int n){int i;p=head;p->next=NULL;for(i=1;i<=n;i++){//将猴子顺序编号q=(ListNode *)malloc(sizeof(ListNode));q->data=i;p->next=q;p=q;p->next=NULL;}return head;//返回链表头指针}/****************打印链表***************/void printlist(Linklist head){p=head->next;while(p){//打印链表直至链表结尾cout<<p->data<<" ";p=p->next;}}/**************删除被选到的猴子*****************/void Delete(ListNode *b,ListNode *pb) /*pb为删除结点的前驱*/{pb->next=b->next;free(b);}/**************猴子选大王(数n个)**************/int King(Linklist head,int n,int i){int j,k;ListNode *pp,*t; /*删除节点前驱*/p=head;if(i==1) return i;while(i!=1){for(j=0;j<n;j++){//数到第n个猴子pp=p;p=p->next;if(!p) p=head->next;}if(!p->next) t=head;//当删除的结点为最后一个结点时,t指向头结点else t=pp;Delete(p,pp);p=t;i--;}k=pp->data;//将最后一只猴子的编号赋值给kreturn k;//返回最后一只猴子编号}void main(){int i,c,k,flag=0;//falg:整型变量,与int相似cout<<"请输入猴子数量"<<endl;cin>>i;cout<<"--------------将猴子顺序编号--------------"<<endl;printlist(Create(i));//调用将猴子顺序编号的函数cout<<endl<<"-----------------编号结束-----------------"<<endl;while(!flag){cout<<"第几个猴子离开?"<<endl;cin>>c;if(c>i) cout<<"输入数量大于猴子数量,请重新输入"<<endl;if(c<i||c==i) flag=1;}k=King(head,c,i);//调用猴子选大王函数cout<<"大王编号为"<<k<<endl;}【结果截图】【收获及体会】猴子选大王是一个数据结构很古老很经典的问题,融知识性和娱乐性为一体,能让人产生较大兴趣。

PHP实现猴子选大王问题的算法

PHP实现猴子选大王问题的算法

PHP 实现猴子选大王问题的算法PHP 实现猴子选大王问题的算法我们的事业就是学习再学习,努力积累更多的知识,因为有了知识,社会就会有长足的进步,人类的未来幸福就在于此。

以下是店铺为大家搜索整理的PHP 实现猴子选大王问题的算法,希望对大家有所帮助!一、问题:n 只猴子围坐成一个圈,按顺时针方向从1到n 编号。

然后从1号猴子开始沿顺时针方向从1开始报数,报到m 的猴子出局,再从刚出局猴子的`下一个位置重新开始报数,如此重复,直至剩下一个猴子,它就是大王。

设计并编写程序,实现如下功能:(1) 要求由用户输入开始时的猴子数$n 、报数的最后一个数$m 。

(2) 给出当选猴王的初始编号。

二、解决方法:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 /*** @param int $n 开始时的猴子数量* @param int $m 报道的最后一个数*(报到这个数的猴子被淘汰,然后下一个猴子重新从①开始报数) * @return int 猴子的初始编号*/function monkeySelectKing($n,$m){//猴子的初始数量不能小于2if ($n<2){return false;}$arr=range(1,$n);//将猴子分到一个数组里, 数组的值对应猴子的初始编号$unsetNum=0;//定义一个变量,记录猴子的报数20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 for ($i = 2; $i <=$n*$m ; $i++)//总的循环次数不知道怎么计算,{//不过因为循环中设置了return,所以$m*$len 效率还可以 foreach ($arr as $k => $v){$unsetNum++; //每到一个猴子, 猴子报数+1//当猴子的报数等于淘汰的数字时:淘汰猴子(删除数组元素) //报数归0(下一个猴子从1开始数)if ($unsetNum==$m){// echo "<pre>";//打开注释,可以看到具体的淘汰过程 // print_r($arr);unset($arr[$k]);//淘汰猴子$unsetNum=0;//报数归零if (count($arr)==1)//判断数组的长度, 如果只剩一个猴子, 返回它的值 {return reset($arr);}}}}}var_dump(monkeySelectKing(6, 3));补充改进算法(该算法更加简洁明了!):1 2 3 4 5 6 7 8 9 function yuesefu($n,$m) {$r=0;for($i=2; $i<=$n; $i++) {$r=($r+$m)%$i;}return $r+1;}print_r(yuesefu(3,3));。

数据结构猴子选大王课程设计

数据结构猴子选大王课程设计

《数据结构》课程设计题目:猴子选大王一、需求分析:猴子选大王是一个很古老经典的题目,融知识性、娱乐性与一体,能让人产生较大的兴趣,因此,编写程序实现之是意见很有意思的事情。

猴子选大王的问题可以归结为筛选和排序的问题,筛选主要是从一群猴子中,比如M 个中每次选出一只猴子,该猴子离开;排序主要是第N只猴子离开后,剩下的猴子要重新编号,继续上面的过程,知道选出猴子大王。

为了增强与用户的交互,程序需要一个比较好的操作界面,用户在其中输入猴子总数M 和被淘汰猴子数目(游戏规则数字)N,输入要符合要求,即M>N,否则要提示错误信息;在点了确定以后要弹出信息提示对话框,告知使用者猴子大王的编号。

二、概要设计:1.程序中使用的存储结构:Node结构体struct node{int num;struct node *link;} node;结构体指针变量node *head,*p,*q;2.由于本题数据元素的个数不可预知,同时对于报完一次之后对于下一次的报数,由于已经排除了一部分猴子,猴子的顺序被打乱,所以使用链表。

链表是动态的,可以在需要的时候增长和减少其长度,而静态数据结构数组是在编译时分派内存的,其大小是不可改变的,而且会出现内存浪费的情况。

我认为单循环链表能较好的解决问题,在建立循环链表时,因为链表的大小由输入决定,因此与匹配的结点数也是变化的,所以要进行动态内存分配。

假设猴子的个数是n,m是要淘汰的编号,那么建立一个n长的链表,链表最后一个元素的next指针指向第一个元素,这样就形成一个循环链表,而链表的数据域储存的就是猴子的编号。

3.整体流程图如下:开始输入M的值输入N的值M > N提示输入错误信息要求重新输入输出猴子大王的编号结束三、详细设计:1.程序首先定义一个结构体如下,其中num用来指示猴子的编号;结构体类型的指针link放在链表中操作;以及一个结构体变量node;struct node{int num;struct node *next;};2.用链表实现课题功能、程序中的异常处理主要放在“确定”事件响应中实现:typedef struct node NODE;NODE *create_link_list(int m){int i;NODE *head, *p, *q;//if (m==0) return NULL;head = (NODE *) malloc(sizeof(NODE));p = head;for (i=1; i<m; i++){p->num=i;q=(NODE *)malloc(sizeof(NODE));p->next=q;p=q;}p->num=m;p->next=head;return (head);}NODE *select_king(NODE **head,int m,int n){NODE *p,*q,*u;int i,d;p=*head;// printf("The header of the list is %d\n",p->num); //指向创建动态链的表头for(i=m;i>1;i--){// printf("Now,the number of monkey is %d\n",i); //检测当前还有多少只猴子for(d=1;d<n;d++){q=p;p=q->next;// printf("Monkey %d\n",q->num); //显示此次参与循环的猴子的编号}u=p->next;q->next=p->next;free(p);p=u;// printf("the next number is %d\n",p->num); //显示下一次循环中的第一个猴子编号}return(p); //容易出错点,长返回值不能清楚}3.该程序的主程序如下:void main(){int a,b;NODE *my_head,*k;printf("请输入猴子个数:\n");scanf("%d",&a);printf("请输入游戏规则中的数字:\n");scanf("%d",&b);if(a<1||b<1)printf("您输入的数字超出了规定的范围!\n");else if(b>=a)printf("输入游戏中的数字只能小于猴子个数!\n");else{my_head=create_link_list(a);k=select_king(&my_head,a,b);printf("按照这种规则,猴王的编号是%d\n",k->num);}}四、调试分析:1.程序运行将会出现如下的界面:2.程序输入数据运行后又将会出现如下的界面:2.测试数据3.结果分析通过以上数据对程序的测试分析可知,本程序很好地完成了题目的要求,并且增加了许多有趣的功能,对意外情况也处理得比较到位。

php正常的猴子选大王算法

php正常的猴子选大王算法

php正常的猴⼦选⼤王算法⼀群猴⼦排成⼀圈,按1,2,...,n依次编号。

然后从第1只开始数,数到第m只,把它踢出圈,从它后⾯再开始数,再数到第m只,在把它踢出去...,如此不停的进⾏下去,直到最后只剩下⼀只猴⼦为⽌,那只猴⼦就叫做⼤王。

⽰意图:php代码:$arr = array(1,2,3,4,5,6,7,8,9,10);//⽰例数组echo 'The King is :';print_r(King($arr,12));function King($arr,$count){while(count($arr) != 1){//如果数组只剩⼀个,就是⼤王,即结果$length = count($arr);//统计本次循环数组所剩数⽬if($length >= $count){//如果所要压出数组直接可以点出来$res = array_splice($arr,$count-1,1);//压出数组}else{$remainder = $count%$length;//求余数,即为所要压出数组的元素if($remainder == 0){$remainder = $length;//如果求余结果为0,即时为本数组最后⼀个元素}$res = array_splice($arr,$remainder-1,1);//压出数组}}return $arr;//返回所求,即⼤王}function killMonkey($monkeys , $m , $current = 0){$number = count($monkeys);$num = 1;if(count($monkeys) == 1){echo $monkeys[0]."成为猴王了";return;}else{while($num++ < $m){$current++ ;$current = $current%$number;}echo $monkeys[$current]."的猴⼦被踢掉了";array_splice($monkeys , $current , 1);killMonkey($monkeys , $m , $current);}}$monkeys = array(1 , 2 , 3 , 4 , 5 , 6 , 7, 8 , 9 , 10); //monkeys的编号$m = 4; //数到第⼏只猴⼦被踢出killMonkey($monkeys , $m);function king($m, $n) {for($i = 1;$i < $m + 1;$i++) {//构建数组$arr[] = $i;}$i = 0;//设置数组指针while (count($arr) > 1) {//遍历数组,判断当前猴⼦是否为出局序号,//如果是则出局,否则放到数组最后if (($i + 1) % $n == 0) {unset($arr[$i]);} else {array_push($arr, $arr[$i]);//本轮⾮出局猴⼦放数组尾部unset($arr[$i]);//删除}$i++;}return $arr;}var_dump(king(100,5));。

基础算法之一——模拟法

基础算法之一——模拟法

基础算法之⼀——模拟法基础算法之⼀——模拟法“约瑟夫环问题”题⽬描述有n只猴⼦,按顺时针⽅向围成⼀圈选⼤王(编号从1到n),从第1号开始报数,⼀直数到m,数到m的猴⼦退出圈外。

剩下的猴⼦再接着从1开始报数,就这样,直到圈内只剩下⼀只猴⼦时,这个猴⼦就是猴王。

编程输⼊n和m,输出最后猴王的编号输⼊数据每⾏是⽤空格分开的两个整数。

第⼀个是n,第⼆个是m(0<m,n<300);最后⼀⾏是0 0输出要求对于每⾏输⼊数据(最后⼀⾏除外),输出数据也是⼀⾏,即最后猴王的编号。

输⼊样例6 212 48 30 0输出样例517⼼得这道题主要是按照思路⾛可以,也就是模拟该过程。

另外,编程实现时也要讲究。

1、如何实现存放n个数?(数组)2、遇到应当退出的猴⼦,如何操作?(剔除元素,或者该位置重置)3、遍历到n个数结尾,如何从头计数?(回到第⼀个元素,重新循环)解题思路:java语⾔描述import java.util.ArrayList;import java.util.Iterator;import java.util.Scanner;public class Q2746 {public static void main(String[] args) {//接收输⼊的流Scanner scanner = new Scanner(System.in);//执⾏三次while (true) {String string;String[] str;//使⽤‘换⾏符’作为读取的分割符,string存放读⼊的⼀⾏数据,str存放切割的每⼀个元素string = eDelimiter("\n").next();if (string.equals("0 0")) {break;}str = string.split(" ");/** 此处我使⽤的数据结构是arraylist,是由于他的iterator可以被利⽤来遍历。

链表_猴子选大王

链表_猴子选大王
猴子选大王
• 题目描述:n只猴子要选大王,选举方法如下: 所有猴子按 1,2 ……… n 编号并按照顺序围成 一圈,从第 k 个猴子起,由1开始报数,报到m 时,该猴子就跳出圈外(从链表中删除),下 一只猴子再次由1开始报数,如此循环,直到圈 内剩下一只猴子时,这只猴子就是大王。 • 输入数据:猴子总数n,起始报数的猴子编号k, 出局数字m • 输出数据:猴子的出队序列和猴子大王的编号
要求:
• 要求在两节课内完成编程和设计 • 在下课前提交给老师检查,并登记成绩,下课铃 声响起后停止检查 • 要求用链表实现,链表的创建、输出、删除等功 能分别由函数实现 • 检查时录入数据值是: n=5,k=2,m=3 • 正确输出应该是
– 跳出圈外的猴子依次为:4 2 1 3 – 5是大王
ห้องสมุดไป่ตู้
正确输出分析n=5,k=2,m=3 • • • • • 12345 1235 135 35 5 4跳出 2跳出 1跳出 3跳出 5是大王

PHP实现的猴王算法(猴子选大王)示例

PHP实现的猴王算法(猴子选大王)示例

PHP实现的猴王算法(猴⼦选⼤王)⽰例本⽂实例讲述了PHP实现的猴王算法。

分享给⼤家供⼤家参考,具体如下:<?phpfunction getKingMokey($n, $m){$monkey[0] = 0;//将1-n只猴⼦顺序编号⼊数组中for($i= 1; $i<= $n; $i++){$monkey[$i] = $i;}$len = count($monkey);//循环遍历数组元素(猴⼦编号)for($i= 0; $i< $len; $i= $i){$num = 0;foreach($monkey as $key => $value){if($value == 0) continue;$num++;$values = $value;}//若只剩⼀只猴⼦则输出该猴⼦编号(数组元素值) 并退出循环if($num == 1){echo $values;exit;}//将第$i只猴⼦踢出队伍(相应数组位置元素值设为0)$monkey[$i] = 0;//打印该猴⼦位置echo $i."";//设置计数器for($j= 1; $j<= $m; $j++){//猴⼦编号加⼀,遍历下⼀只猴⼦$i++;//若该猴⼦未被踢出队伍,获取下⼀只猴⼦编号if($monkey[$i] > 0) continue;//若元素值为0,则猴⼦已被踢出队伍,进⽽循环取下⼀只猴⼦编号if($monkey[$i] == 0){//取下⼀只猴⼦编号for($k= $i; $k< $len; $k++){//值为0,编号加1if($monkey[$k] == 0) $i++;//否则,编号已取得,退出if($monkey[$k] > 0) break;}}//若编号⼤于猴⼦个数,则从第0只猴⼦开始遍历(数组指针归零)//步骤同上if($i == $len) $i = 0;//同上步骤,获取下⼀只猴⼦编号if($monkey[$i] == 0){for($k= $i; $k< $len; $k++){if($monkey[$k] == 0) $i++;if($monkey[$k] > 0) break;}}}}}//猴⼦个数$n = 10;//踢出队伍的编号间隔值$m = 3;//调⽤猴王获取函数getKingMokey($n, $m);>运⾏结果:036927185104⽤递归的算法$monkeys = array(1 , 2 , 3 , 4 , 5 , 6 , 7, 8 , 9 , 10); //monkey的编号$m = 4; //数到第⼏只的那只猴⼦被踢出去function killMonkey($monkeys , $m , $current = 0){$number = count($monkeys);$num = 1;if(count($monkeys) == 1){echo $monkeys[0]."成为猴王了";return;}else{while($num++ < $m){$current++ ;$current = $current%$number;}echo $monkeys[$current]."的猴⼦被踢掉了<br/>";array_splice($monkeys , $current , 1);killMonkey($monkeys , $m , $current);}}killMonkey($monkeys , $m);运⾏结果:4的猴⼦被踢掉了8的猴⼦被踢掉了2的猴⼦被踢掉了7的猴⼦被踢掉了3的猴⼦被踢掉了10的猴⼦被踢掉了9的猴⼦被踢掉了1的猴⼦被踢掉了6的猴⼦被踢掉了5成为猴王了更多关于PHP相关内容感兴趣的读者可查看本站专题:《》、《》、《》、《》、《》及《》希望本⽂所述对⼤家PHP程序设计有所帮助。

第六章模拟

第六章模拟

排列
1 到n 这n 个数可以构成n!种排列,把这些排列按 照从小到大的顺序(字典顺序)列出,如n=3 时,列 出1 2 3,1 3 2,2 1 3,2 3 1,3 1 2,3 2 1六个排列。
给出某个排列,求出这个排列后面的第k个排列,如 果遇到最后一个排列,则下1排列为第1个排列,即排 列1 2 3 …n
char n3[11] = {"||||| |||"}; char n4[11] = {" ----- --"};
char n5[11] = {"| | | | "}; char n6[11] = {"|| |||||||"};
char n7[11] = {"- -- -- --"};
void main()
注意:可能只有部分植株下面长有花生,假设这些 植株下的花生个数各不相同。
花生问题
输入:第一行一个整数,表示测试数据的组数,第 二行包括三个整数:M、N和K;表示花生田的大小 为M*N,采花生的限定时间为K(0<= K<=1000) 个单位时间,接下来的M行,每行包括N个非负整数, 也用空格隔开;第i+1行的第j个整数Pij(0 <= Pij <= 500)表示花生田里植株(i,j)下花生的数目,0表示该 植株下没有花生。
显示器
1
2
3
4
5
6
7
一个计算器上的数字可以看作由编号从 1 到 7 的7 个笔画组成。如数字 8 覆盖了所有 的笔画,数字 7 覆盖笔画 1、3 和 6,而数 字 1 覆盖笔画3、6。注意,每个笔画都是 由s 个’-‘或s 个’|’组成。
显示器
先输出第 1 行,即整数n中所有数字里的笔画1, 然后输出第2 行到第s+1 行,即所有数字的笔画 2 和笔画3,接下来是第s+2 行,即所有数字的 笔画4,再接下来是第s+3行到2×s+2 行,就是 所有数字的笔画 5 和笔画 6,最后的第2×s+3 行,是所有数字的笔画7。如果某数字d 没有覆 盖某个笔画m (m = 1…7),那么,输出数字d 的 笔画m 时, 就输出空格;如果覆盖了笔画m, 则输出s 个’-‘或s 个’|’,这取决于笔画m 是横 还是竖。

数据结构猴子选大王2024

数据结构猴子选大王2024

引言概述:数据结构猴子选大王(二)是继第一部分后的深入探讨。

本文将详细介绍猴子选大王问题的背景和相关算法,探讨不同数据结构在解决该问题时的优劣,并提出一种性能更高的改进算法。

通过对本文的阅读,读者将对数据结构在解决复杂问题中的应用有更深入的理解。

正文内容:一、背景介绍1.1问题描述:数据结构猴子选大王问题是一个经典的计算机科学问题,它描述了一群猴子按一定规则进行选举的过程。

1.2算法原理:猴子选大王问题可以通过循环链表和递归两种方法进行解决,其中循环链表是最常用的解法。

1.3算法过程:通过将猴子按一定顺序编号,然后循环一个圈,每次淘汰某一编号的猴子,直到只剩下最后一只为止,即为大王。

二、循环链表算法2.1数据结构选择:循环链表是解决猴子选大王问题的主要数据结构。

其特点是每个节点都有一个指针指向下一个节点,且最后一个节点指向第一个节点。

2.2算法流程:在循环链表中,通过不断遍历并淘汰节点,最终得到最后剩下的节点作为大王。

2.3时间复杂度分析:循环链表算法的时间复杂度为O(mn),其中m是猴子的总数,n是每次淘汰的数量。

三、改进算法3.1基于队列的改进算法:针对循环链表算法中的时间复杂度较高的问题,可以考虑采用队列的数据结构进行改进。

3.2算法优化:通过将猴子的编号依次入队,然后每次从队首取出一个猴子,再将其编号入队尾,直到只剩下一只为止。

3.3时间复杂度分析:改进算法的时间复杂度为O(m),其中m 是猴子的总数。

四、数据结构选择4.1循环链表的优势:循环链表是解决猴子选大王问题的经典数据结构之一,具有结构简单、操作灵活等优点。

4.2队列的优势:队列是改进算法中的数据结构选择,具有先进先出、操作高效等特点。

4.3不同数据结构的比较:循环链表适用于猴子选大王问题的普遍情况,而队列作为改进算法可以在处理大规模数据时提高效率。

五、总结本文详细介绍了数据结构猴子选大王(二)的相关算法和背景,在对循环链表和基于队列的改进算法进行比较后,提出了一种性能更高的改进算法。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

for(i=n; i>=2; i--) //进行(n-2+1) = (n-1)轮处理,每次把第i个人报数后出圈,
{
s1=(s1+m-1)%i; //定位那个出圈的人的顺序号i
if(s1==0)
s1=i; //若s1=0表示本测出圈的队列中的最后一个人
现要求按出圈次序,每10人一组,给出这n个人的顺序表。
请考生编制函数Josegh()实现此功能并调用函数WriteDat()把结果p输出到文件OUT.DAT中。
设n=100,c=1,m=10.
printf("\n");
for(i=M-1;i>=0;i--)
{
for(k=1;k<=S;k++)
{
temp=a[0];
for(j=0;j<i;j++)
LINK p,head,p2;
int i;
head=p=p2=(LINK)malloc(sizeof(Monkey));
for(i=1;i<n;i++)
{
p=(LINK)malloc(sizeof(Monkey));
p2->next=p;
p2=p;
a[j]=a[j+1];
a[i]=temp;
}
}
for(i=M-1;i>=0;i--)
printf("猴子出列的顺序如下:%d ",a[i]);
//则将p[i]置于数组的倒数第i个位置上,
//而原来第i+1个至倒数第i个元素依次向前移动一个位置。
printf("\n");
p2->next=p->next;
p=p2->next;
continue;
}
else
{
if(i==m-1) p2=p;
p=p->next;
}
}
printf("胜出:%d",p->num);
p[j-1]=p[j];
p[i-1]=w; 则将p[i]置于数组的倒数第i个位置上
}
#define M 10
int p[100],n,s,m;
void WriteDat(void);
void Josegh(void)
{
}
p2->next=head;
p=head;
printf("对猴子进行编号!\n");
for(i=1;i<=n;i++)
{
p->num=i;
printf("%d号猴子:%d\n",p->num,p->num);
p=p->next;
#define S 3/*数猴子轮N出圈*/
void main()
{
int i,j,k,temp,a[M];
for(i=0;i<43;1;
for(i=0;i<M;i++)
printf("原始的数组顺序如下:%d ",a[i]);
w=p[s1-1]; //w为出圈的那个人的真实序号,因为1-n保存在p[i-1]中
for(j=s1; j<i; j++) //原来第i+1个至倒数第i个元素依次向前移动一个位置。
}
++++++++++++++++++++++++++++++++++
这个程序的输入是猴子出列的顺序,数组的第一个就是大王的编号,呵呵
上面的输入结果如下:
1 2 3 4 5 6 7 8 9 10
3 6 9 2 7 1 8 5 10 4 Press any key to continue
}
不理解第二个FOR与第三个FOR的意思,阁下请帮帮忙?
部分源程序已给出。
请勿改动主函数main()和输出数据函数writeDat()的内容。
#include <stdio.h>
#define N 100
#define S 1
int i,j,s1,w;
s1=s;
for(i=1; i<=n; i++) //将1到n个人的序号存入一维数组p[i-1]中
p[i-1]=i;
}
i=0;
p=head;
while(1)
{
i++;
printf("%d号猴子报:%d\n",p->num,i);if(p->next==p) break;
if(i==m)
{
i=0;
printf("%d号猴被淘汰\n",p->num);
可见,大王就是4。
先给你整理一下问题是否如下:
设有n个人围坐一圈并按顺时针方向从1到n编号。
从第s个人开始进行1到m的报数,报数到第个m人,此人出圈,再从他的下一个人重新开始1到m的报数,如此进行下去直到所有的人都出圈为止。
#include <stdio.h>
#include <stdlib.h>
#define n 20
#define m 5
typedef struct monkey
{
int num;
struct monkey *next;
} Monkey,*LINK;
int main()
{
(1)将1到n个人的序号存入一维数组p中;
(2)若第i个人报数后出圈,则将p[i]置于数组的倒数第i个位置上,而原来第i+1个至倒数第i个元素依次向前移动一个位置;
(3)重复第(2)步直至圈中只剩下p[1]为止。
}
// 上边这个问题又称为约瑟夫环问题,解法很多,这个用的指针。这是个属于数据结构的问题
这个做的不全面是用循环判断谁是最后一个出去的,看谁是大王。
++++++++++++++++++++++++++++++++++
#include<stdio.h>
#define M 10/*定义猴子总数*/
相关文档
最新文档