课程设计—约瑟夫双向生死问题

最新推荐文章于 2021-05-19 11:30:46 发布
最新推荐文章于 2021-05-19 11:30:46 发布
阅读量2.6k 收藏 33
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1034311243/article/details/53886824
版权

问题及描述：


约瑟夫双向生死问题是建立在约瑟夫问题基础上，正向计数后反向计数，然后在正向计数，然后在正向计数。具体描述如下：30个旅客同乘一条船，因为严重过载，加上风浪高大，危险万分；因此船长告诉乘客，只有将全船一半的旅客投入海中，其余人才能幸免遇难。无奈，大家只得同意这种方法，并议定30个人围成一圈，由第一个人开始，顺时针依次报数，数到第九人，便把他投入大海中，然后从他的下一个人数起，逆时针数到第5人，将他投入大海，然后从他逆时针的下一个人数起，顺时针数到第9人，再将他投入大海，如此循环，直到剩下15个乘客为止。问那些乘客是将被扔下大海的位置。


顺序表方式：

list.h

#define MaxSize 50    
typedef int ElemType;    
typedef struct    
{    
    ElemType data[MaxSize];    
    int length;    
} SqList;    
void CreateList(SqList *&L, ElemType a[], int n);//用数组创建线性表    
void InitList(SqList *&L);//初始化线性表InitList(L)    
void DestroyList(SqList *&L);//销毁线性表DestroyList(L)    
bool ListEmpty(SqList *L);//判定是否为空表ListEmpty(L)    
int ListLength(SqList *L);//求线性表的长度ListLength(L)    
void DispList(SqList *L);//输出线性表DispList(L)    
bool GetElem(SqList *L,int i,ElemType &e);//求某个数据元素值GetElem(L,i,e)    
int LocateElem(SqList *L, ElemType e);//按元素值查找LocateElem(L,e)    
bool ListInsert(SqList *&L,int i,ElemType e);//插入数据元素ListInsert(L,i,e)    
bool ListDelete(SqList *&L,int i,ElemType &e);//删除数据元素ListDelete(L,i,e)

list.cpp    (对算法的listdelete进行修改) 

#include <stdio.h>    
#include <malloc.h>    
#include "list.h"    
    
//用数组创建线性表    
void CreateList(SqList *&L, ElemType a[], int n)    
{    
    int i;    
    L=(SqList *)malloc(sizeof(SqList));    
    for (i=0; i<n; i++)    
        L->data[i]=a[i];    
    L->length=n;    
}    
    
//初始化线性表InitList(L)    
void InitList(SqList *&L)   //引用型指针    
{    
    L=(SqList *)malloc(sizeof(SqList));    
    //分配存放线性表的空间    
    L->length=0;    
}    
    
//销毁线性表DestroyList(L)    
void DestroyList(SqList *&L)    
{    
    free(L);    
}    
    
//判定是否为空表ListEmpty(L)    
bool ListEmpty(SqList *L)    
{    
    return(L->length==0);    
}    
    
//求线性表的长度ListLength(L)    
int ListLength(SqList *L)    
{    
    return(L->length);    
}    
    
//输出线性表DispList(L)    
void DispList(SqList *L)    
{    
    int i;    
    if (ListEmpty(L)) return;    
    for (i=0; i<L->length; i++)    
        printf("%d ",L->data[i]);    
    printf("\n");    
}    
    
//求某个数据元素值GetElem(L,i,e)    
bool GetElem(SqList *L,int i,ElemType &e)    
{    
    if (i<1 || i>L->length)  return false;    
    e=L->data[i-1];    
    return true;    
}    
    
//按元素值查找LocateElem(L,e)    
int LocateElem(SqList *L, ElemType e)    
{    
    int i=0;    
    while (i<L->length && L->data[i]!=e) i++;    
    if (i>=L->length)  return 0;    
    else  return i+1;    
}    
    
//插入数据元素ListInsert(L,i,e)    
bool ListInsert(SqList *&L,int i,ElemType e)    
{    
    int j;    
    if (i<1 || i>L->length+1)    
        return false;   //参数错误时返回false    
    i--;            //将顺序表逻辑序号转化为物理序号    
    for (j=L->length; j>i; j--) //将data[i..n]元素后移一个位置    
        L->data[j]=L->data[j-1];    
    L->data[i]=e;           //插入元素e    
    L->length++;            //顺序表长度增1    
    return true;            //成功插入返回true    
}    
    
//删除数据元素ListDelete(L,i,e)    
bool ListDelete(SqList *&L,int i,ElemType &e)    
{    
    int j;    
    if (i<0 || i>L->length)  //参数错误时返回false    
        return false; 
	if(i==0)        //
	i=L->length;    // 对j=0 的修改(2行)
    i--;        //将顺序表逻辑序号转化为物理序号    
    e=L->data[i];    
    for (j=i; j<L->length-1; j++) //将data[i..n-1]元素前移    
        L->data[j]=L->data[j+1];    
    L->length--;              //顺序表长度减1    
    return true;              //成功删除返回true    
}
 


main.cpp

#include "list.h"    
#include <stdio.h>    
void main()        
{        
SqList *sq;    
int n,f,s;  //n代表船上的总人数,f代表第一次顺时针方向数的个数，s代表第二次逆时针的个数    
int i,j=1;   // j记录当前位置     
printf("请输入船上的总人数：\n");    
scanf("%d",&n);    
printf("请输入顺时针方向的人数：\n");    
scanf("%d",&f);    
printf("请输入逆时针方向的人数：\n");    
scanf("%d",&s);      
printf("请输入开始位置的人的序号：\n");  
scanf("%d",&j);  
ElemType x[1000],e;     
for(i=0;i<n;i++)    
x[i]=i+1;                    //初始化数组    
  
  
CreateList(sq, x, n);      // 创建线性表  
  
for(i=0;i<n/2;i++)                //从第一个位置开始，第一次顺时针9人，第二次逆时针5人如此循环    
{     
if(i%2==0)               // 以奇偶区分顺、逆时针方向    
{    
j=((j+f-1)+sq->length)%sq->length;   //从第一个位置开始，顺时针数9个位置，应移动8个位置8    
if(j==0)
j=sq->length;  //   j=0 表示为最后一个元素


if(ListDelete(sq,j,e))       
printf("第%d次出局的序号为：%d\n",i+1,e); //删除并输出该元素      


j=j%sq->length;   // 结果修正（ 处理j为最后一个元素的情况  下一次j开始时是从第一个位置 ）
}   
//顺时针的方法下一次开始的位置为j（在删除元素时是一次从下一个位置补上来）  




else    // 逆时针移动5个位置    
{    
j=((j-(s-1))+sq->length)%sq->length;   //从第一个位置开始，逆时针数5个位置，应为移动4个位置    
if(j==0)
j=sq->length;
if(ListDelete(sq,j,e))    


printf("第%d次出局的序号为：%d\n",i+1,e); //删除并输出该元素    
                
j=(j-1)%sq->length;  // 结果修正（j为第一个元素）
} //逆时针的方法下一次开始的位置为j-1  
  
  
}    
printf("剩余的序号为：\n");    
DispList(sq);    
  
  
}        


运行结果：





循环双链表方式：

cdlinklist.h

#ifndef CDLINKLIST_H_INCLUDED
#define CDLINKLIST_H_INCLUDED

//循环双链表基本运算函数
typedef int ElemType;
typedef struct DNode        //定义双链表结点类型
{
    ElemType data;
    struct DNode *prior;    //指向前驱结点
    struct DNode *next;     //指向后继结点
} CDLinkList;

void CreateListF(CDLinkList *&L,ElemType a[],int n); //头插法建立循环双链表
void CreateListR(CDLinkList *&L,ElemType a[],int n); //尾插法建立循环双链表
void InitList(CDLinkList *&L); //初始化循环双链表
void DestroyList(CDLinkList *&L);  //销毁
bool ListEmpty(CDLinkList *L); //判断是否为空
int ListLength(CDLinkList *L); //求链表长度
void DispList(CDLinkList *L);  //输出链表
bool GetElem(CDLinkList *L,int i,ElemType &e);  //取链表元素
int LocateElem(CDLinkList *L,ElemType e);  //查找元素
bool ListInsert(CDLinkList *&L,int i,ElemType e);  //插入节点
bool ListDelete(CDLinkList *&L,int i,ElemType &e);  //删除节点

#endif // CDLINKLIST_H_INCLUDED


cdlinklist.cpp

 
#include <stdio.h>
#include <malloc.h>
#include "cdlinklist.h"
void CreateListF(CDLinkList *&L,ElemType a[],int n) //头插法建立循环双链表
{
    CDLinkList *s;
    int i;
    L=(CDLinkList *)malloc(sizeof(CDLinkList));     //创建头结点
    L->next=NULL;
    for (i=0; i<n; i++)
    {
        s=(CDLinkList *)malloc(sizeof(CDLinkList));//创建新结点
        s->data=a[i];
        s->next=L->next;            //将*s插在原开始结点之前,头结点之后
        if (L->next!=NULL) L->next->prior=s;
        L->next=s;
        s->prior=L;
    }
    s=L->next;
    while (s->next!=NULL)           //查找尾结点,由s指向它
        s=s->next;
    s->next=L;                      //尾结点next域指向头结点
    L->prior=s;                     //头结点的prior域指向尾结点


}
void CreateListR(CDLinkList *&L,ElemType a[],int n) //尾插法建立循环双链表
{
    CDLinkList *s,*r;
    int i;
    L=(CDLinkList *)malloc(sizeof(CDLinkList));  //创建头结点
    L->next=NULL;
    r=L;                    //r始终指向尾结点,开始时指向头结点
    for (i=0; i<n; i++)
    {
        s=(CDLinkList *)malloc(sizeof(CDLinkList));//创建新结点
        s->data=a[i];
        r->next=s;
        s->prior=r; //将*s插入*r之后
        r=s;
    }
    r->next=L;              //尾结点next域指向头结点
    L->prior=r;             //头结点的prior域指向尾结点
}
void InitList(CDLinkList *&L) //初始化循环双链表
{
    L=(CDLinkList *)malloc(sizeof(CDLinkList));     //创建头结点
    L->prior=L->next=L;
}
void DestroyList(CDLinkList *&L)  //销毁
{
    CDLinkList *p=L,*q=p->next;
    while (q!=L)
    {
        free(p);
        p=q;
        q=p->next;
    }
    free(p);
}
bool ListEmpty(CDLinkList *L) //判断是否为空
{
    return(L->next==L);
}
int ListLength(CDLinkList *L) //求链表长度
{
    CDLinkList *p=L;
    int i=0;
    while (p->next!=L)
    {
        i++;
        p=p->next;
    }
    return(i);
}
void DispList(CDLinkList *L)  //输出链表
{
    CDLinkList *p=L->next;
    while (p!=L)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
bool GetElem(CDLinkList *L,int i,ElemType &e)  //取链表元素
{
    int j=0;
    CDLinkList *p;
    if (L->next!=L)     //双链表不为空表时
    {
        if (i==1)
        {
            e=L->next->data;
            return true;
        }
        else            //i不为1时
        {
            p=L->next;
            while (j<i-1 && p!=L)
            {
                j++;
                p=p->next;
            }
            if (p==L)
                return false;
            else
            {
                e=p->data;
                return true;
            }
        }
    }
    else                //双链表为空表时
        return 0;
}
int LocateElem(CDLinkList *L,ElemType e)  //查找元素
{
    int n=1;
    CDLinkList *p=L->next;
    while (p!=NULL && p->data!=e)
    {
        n++;
        p=p->next;
    }
    if (p==NULL)
        return(0);
    else
        return(n);
}
bool ListInsert(CDLinkList *&L,int i,ElemType e)  //插入节点
{
    int j=0;
    CDLinkList *p=L,*s;
    if (p->next==L)                 //原双链表为空表时
    {
        s=(CDLinkList *)malloc(sizeof(CDLinkList)); //创建新结点*s
        s->data=e;
        p->next=s;
        s->next=p;
        p->prior=s;
        s->prior=p;
        return true;
    }
    else if (i==1)                  //原双链表不为空表但i=1时
    {
        s=(CDLinkList *)malloc(sizeof(CDLinkList)); //创建新结点*s
        s->data=e;
        s->next=p->next;
        p->next=s;  //将*s插入到*p之后
        s->next->prior=s;
        s->prior=p;
        return true;
    }
    else
    {
        p=L->next;
        while (j<i-2 && p!=L)
        {
            j++;
            p=p->next;
        }
        if (p==L)               //未找到第i-1个结点
            return false;
        else                    //找到第i-1个结点*p
        {
            s=(CDLinkList *)malloc(sizeof(CDLinkList)); //创建新结点*s
            s->data=e;
            s->next=p->next;    //将*s插入到*p之后
            if (p->next!=NULL) p->next->prior=s;
            s->prior=p;
            p->next=s;
            return true;
        }
    }
}
bool ListDelete(CDLinkList *&L,int i,ElemType &e)  //删除节点
{
    int j=0;
    CDLinkList *p=L,*q;
    if (p->next!=L)                 //原双链表不为空表时
    {
        if (i==1)                   //i==1时
        {
            q=L->next;              //删除第1个结点
            e=q->data;
            L->next=q->next;
            q->next->prior=L;
            free(q);
            return true;
        }
        else                        //i不为1时
        {
            p=L->next;
            while (j<i-2 && p!=NULL)
            {
                j++;
                p=p->next;
            }
            if (p==NULL)                //未找到第i-1个结点
                return false;
            else                        //找到第i-1个结点*p
            {
                q=p->next;              //q指向要删除的结点
                if (q==NULL) return 0;  //不存在第i个结点
                e=q->data;
                p->next=q->next;        //从单链表中删除*q结点
                if (p->next!=NULL) p->next->prior=p;
                free(q);                //释放*q结点
                return true;
            }
        }
    }
    else
        return false;   //原双链表为空表时
}


main.cpp

#include <malloc.h>    
#include <stdio.h>    
#include "cdlinklist.h"    
   
void main()    
{    
    int n,f,s,st,m=1;  //n代表船上的总人数,f代表第一次顺时针方向数的个数，s代表第二次逆时针的个数,a为开始位置的人的序号  


	CDLinkList *dl,*p;    //*dl 为双链表的头指针    *p指向当前指针    
   
	printf("请输入船上的总人数：\n");    // 在创建循环双链表的时候，实际创建的有n+1个元素 头结点也算在其中  


	scanf("%d",&n);  
   
	printf("请输入顺时针方向的人数：\n");  


	scanf("%d",&f);  


	printf("请输入逆时针方向的人数：\n");  


	scanf("%d",&s);  


	printf("请输入开始位置的人的序号：\n");  
    
	scanf("%d",&st); 
	
	int a[1000];       
    
	int i;


	for(i=0;i<n;i++)    
  
  


		a[i]=i+1;                // 初始化数组    
     


	InitList(dl);    
    


	CreateListR(dl, a, n);   //尾插法建立双链表    


	p=dl->next;    //指向表头节点
    
	while(m<st)    //指向开始位置的节点
	{
	
	p=p->next;
	
	m++;
	
	}


//  删除过程    
     
for(i=0;i<n/2;i++)  //从第一个位置开始，第一次顺时针9人，第二次逆时针5人如此循环    
  
  
if(i%2==0)   // 以奇偶区分顺、逆时针方向    
  
  
{     


	CDLinkList *a;    


	int j=0;    
  
while(j<f-1)    //顺时针数9个人，即从第一个位置开始移动8个位置  
  
  
{    
  
  


	p=p->next;    


	if(p==dl)  
              
		j--;    // 运行到头结点时在进行一次移动  
  
  
j++;   
  
  
}    
  
  
printf("出局的序号为：%d\n",p->data);    
     
a=p;                                    
  
  
a->prior->next=a->next;    
  
  
a->next->prior=a->prior;    
    
p=a->next;    // 下一次节点开始的位置（顺时针）  
     
free(a);    
  
  
}    
  
  
else    // 逆时针移动5个位置   
  
  
{    
     
CDLinkList *a;   
  
  
int j=0;    
  
  
while(j<s-1)  //逆时针数5个人，即从第一个位置开始移动4个位置  
  
  
{    
p=p->prior;    
   
if(p==dl)  
  
  
j--;  
  
j++;    
  
  
}    
  
  
printf("出局的序号为：%d\n",p->data);    
     
a=p;                                  //删除节点    
  
  
a->prior->next=a->next;    
  
  
a->next->prior=a->prior;    
     
p=a->prior;    // 下一次节点开始的位置（逆时针）  
     
free(a);    
}    
    
     printf("剩余的序号为：\n");   
  
  
  
  
  
  
  
  
DispList(dl);    //输出剩余的序号  
      
  }    



运行结果：



















                

        

        

    




    

      

        

            

              
                
                  a1034311243
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    2
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    33
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
数据结构实验四  约瑟夫生死游戏

				
			

			

				

					愿时光能缓故人不散
				

				

					04-12
					
					4420
					
				

			

		

		

			
				
实验四  约瑟夫生死游戏
1、实验目的：
利用线性表解决实际问题。
2、实验环境与设备：
已安装Visual Studio 2010（或其以上版本）集成开发环境的计算机。
3、实验原理：
（1）利用线性表的删除功能剔除被杀掉的人。
（2）利用单链表、不带头结点的循环链表或带头结点的循环链表均可实现。
4、实验内容：
约瑟夫生死游戏问题有如下几种表述；
表述一：古代某法官要判决N个犯人的死刑，他有一...

			
		

	



                

              
                



	

		

			

				
					
双向链表实现约瑟夫环

				
			

			

				

					CD__ordinary_word的博客
				

				

					05-10
					
					719
					
				

			

		

		

			
				
功能
用双向循环链表实现约瑟夫问题
n个人围成一个圆圈,首先第1个人从1开始,一个人一个人顺时针报数,报到第m个人,令其出列。然后再从下一个人开始,从1顺时针报数,报到第m个人,再令其出列,…,如此下去,直到圆圈中只剩一个人为止。此人即为优胜者

实现
在链表初始化过程中,根据指定的结点数,建立n个结点
链表提供移动操作,能根据参数指定的方向和步数将当前结点标记在链表中移动
链表通过删除操作实现约瑟夫问题的出列
链表类提供一个约瑟夫操作，来完成约瑟夫问题求解的过程
程序运行后,根据输入指定结点数n,初始化链

			
		

	



                


  
              

                


	

		

			

				
					
约瑟夫问题_公式原理详解

					
热门推荐

				
			

			

				

					小黯
				

				

					04-14
					
					3万+
					
				

			

		

		

			
				
每次增加一个人，我们第一轮的报数被指定的必定是新加入的人。

			
		

	





	

		

			

				
					
约瑟夫双向生死游戏c语言代码,约瑟夫经典问题扩展成双向约瑟夫问题

				
			

			

				

					weixin_35993148的博客
				

				

					05-19
					
					979
					
				

			

		

		

			
				
约瑟夫问题是一个经典的问题，我们不妨将这个经典问题进行扩展，变成一个双向的约瑟夫问题。已知 n 个人(不妨分别以编号 1，2，3，...，n 代表 )围坐在一张圆桌周围，首先从编号为 k 的人从 1 开始顺时针报数，1, 2, 3, ...，记下顺时针数到 m 的那个人，同时从编号为 k 的人开始逆时针报数，1, 2, 3, ...，数到 m 后，两个人同时出列。然后从出列的下一个人又从 1 开始...

			
		

	



		

			
		



	

		

			

				
					
约瑟夫生死游戏

				
			

			

				

					qq_52684161的博客
				

				

					12-03
					
					2571
					
				

			

		

		

			
				
约瑟夫生死者游戏
[问题描述]
约瑟夫（Joeph）问题的一种描述是：编号为1,2,…,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序。
[基本要求]
利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。
[测试数据]
m的初值为20；密码

			
		

	





	

		

			

				
					
数据结构课程设计约瑟夫双向生死问题（附源代码可运行）

					
最新发布

				
			

			

				

					06-12
				

			

		

		

			
				
数据结构课程设计约瑟夫双向生死问题（附源代码完整版）实验报告

			
		

	





	

		

			

				
					
数据结构课程设计约瑟夫生死游戏

				
			

			

				

					06-15
				

			

		

		

			
				
本课程设计的标题是“数据结构课程设计约瑟夫生死游戏”，是数据结构课程设计的一部分，旨在训练学生的数据组织能力和提高程序设计能力。该设计的目的是学习数据结构课程，学会分析研究数据对象的特性，学会数据的...

			
		

	





	

		

			

				
					
约瑟夫双向生死游戏双向队列实现

				
			

			

				

					04-06
				

			

		

		

			
				
约瑟夫双向生死游戏 是约瑟夫生死游戏的改进 使用双向队列实现

			
		

	





	

		

			

				
					
数据结构 约瑟夫生死游戏

				
			

			

				

					06-14
				

			

		

		

			
				
数据结构中的约瑟夫生死游戏是一种经典的算法问题，旨在解决在某个圆环中，每个人的生死次序问题。该问题的解决方案主要基于单循环链表的数据结构和算法实现。  约瑟夫生死游戏的算法思想  约瑟夫生死游戏的算法思想...

			
		

	





	

		

			

				
					
数据结构中双向约瑟夫问题

				
			

			

				

					04-28
				

			

		

		

			
				
已知n个人（不妨分别以编号1，2，3，…，n 代表 ）围坐在一张圆桌周围，首先从编号为 k 的人从1开始顺时针报数，1, 2, 3, ...，记下顺时针数到 m 的那个人，同时从编号为 k 的人开始逆时针报数，1, 2, 3, ...，数到 m 后，两个人同时出列。然后从出列的下一个人又从 1 开始继续进行双向报数，数到m的那两个人同时出列，…；。依此重复下去，直到圆桌周围的人全部出列。直到圆桌周围只剩一个人为止。
数据结构中经典的双向约瑟夫问题c语言代码

			
		

	





	

		

			

				
					
数据结构——约瑟夫生者死者问题

				
			

			

				

					firstcoolboy的专栏
				

				

					03-25
					
					1670
					
				

			

		

		

			
				
#include "stdio.h"#define MAX 50void main(){ int array[MAX]; int m,n,i; int total=0; int record_count=0; printf("请输入报数的人数："); scanf("%d",&m); printf("请输入报数的最大值："); scanf("%d",&n); for(i=0;i<m;i++){ ar

			
		

	





	

		

			

				
					
约瑟夫双向生死游戏c语言代码,数据结构程序设计——约瑟夫双向生死杀人游戏...

				
			

			

				

					weixin_36180385的博客
				

				

					05-19
					
					1538
					
				

			

		

		

			
				
首先是主函数：/***版权所有(C)2017，ShangWenZhe**文件名称：main.cpp*文件标识：无*内容摘要：本文件的作用是调用算法库里面的函数，完成题目要求。*其它说明：无*当前版本：V1.0*作者：尚文哲*完成日期：2017,12,15**/#include#include#include#include"Jd.h"int main(){int total = 30;//总人数i...

			
		

	





	

		

			

				
					
1. 双向约瑟夫问题

				
			

			

				

					liuyi005的专栏
				

				

					12-10
					
					1349
					
				

			

		

		

			
				
1. 双向约瑟夫问题





成绩

10

开启时间

2014年10月21日 Tuesday 12:00



折扣

0.8

折扣时间

2014年11月2日 Sunday 23:55



允许迟交

否

关闭时间

2014年11月9日 Sunday 23:55







　　约瑟夫问题是一个经典的

			
		

	





	

		

			

				
					
顺序表SqList的C++代码实现 

				
			

			

				

					道——世事无常，我心如常
				

				

					07-29
					
					8427
					
				

			

		

		

			
				
C++实现#include iostream>using namespace std;//结构的定义部分const int INITSIZE=3;const int INCREMENT=1;typedef int ElemType;      typedef struct{  ElemType  *elem;  int       length;  int       listsize;}

			
		

	





	

		

			

				
					
双向约瑟夫问题

				
			

			

				

					weixin_38199770的博客
				

				

					01-09
					
					1353
					
				

			

		

		

			
				
成绩

15

开启时间

2017年09月27日 星期三 00:05



折扣

0.8

折扣时间

2017年10月20日 星期五 23:55



允许迟交

否

关闭时间

2018年01月8日 星期一 23:55







　　约瑟夫问题是一个经典的问题，我们不妨将这个经典问题进行扩展，变成一个双向的约瑟夫问题

			
		

	





	

		

			

				
					
Cpp环境【CQYZOJ3531】【CQNOI2016模拟赛（八中出题）】约瑟夫の秘制游戏

				
			

			

				

					天地皆逆旅，你我本行人。
				

				

					10-25
					
					1029
					
				

			

		

		

			
				
【问题描述】  
　　YJC 很喜欢玩游戏，今天他决定和朋友们玩约瑟夫游戏。　　约瑟夫游戏的规则是这样的：n个人围成一圈，从1 号开始依次报数，当报到m 时，报1、2、…、m-1 的人出局，下一个人接着从1 开始报，保证(n-1)是(m-1)的倍数。最后剩的一个人获胜。　　YJC 很想赢得游戏，但他太笨了，他想让你帮他算出自己应该站在哪个位置上。【输入格式】  
　　第一行包含两个整数n 和m，表示

			
		

	





	

		

			

				
					
基于c语言的约瑟夫双向生死游戏的数据结构课程设计

				
			

			

				

					04-08
				

			

		

		

			
				
约瑟夫双向生死游戏是一个经典的计算机科学问题，也是数学和组合的优秀例子。对于这个问题，通常使用一个双向循环链表来实现。每个节点代表一个人，节点中应包含该人的ID、姓名等信息。当一个人出局后，从链表中删除...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值