约瑟夫问题的实现

约瑟夫环问题(Josephus)

第一种情况：

当用户输入任意系列结点值作为约瑟夫环结点元素值时，求解约瑟夫问题。

要求：1.求出输入的结点个数N；

            2.用户输入大于0任意的起点和终点值M时，均可完成josephus任务；

            3.具有详细的结点删除过程，此时时间复杂度为O（N*M）；

            4.通过合理的数学算法推导，写出在时间复杂度为O(N)时的最高效代码。

源代码：

//--------------------

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>

//

// 链表节点
typedef struct _RingNode
{
int pos;  // 位置      
struct _RingNode *next;
}RingNode,*RingNodePtr;

//---根据输入系列元素值自动创建一个约瑟夫环,带空头结点
RingNode *CreateJosephesRing()   
{
RingNodePtr pHead=NULL,pPrev=NULL,pCurr=NULL;
int v_NodeData;
//create header node
pHead = (RingNode*)malloc(sizeof(RingNode));//返回指针型地址值
printf("Please any series of node infomation on and on until -1\n");  //输入一系列任意结点编号如1,3,34,56,67,...,n
//scanf("%d",&v_NodeData);
//pHead->pos = v_NodeData;
pHead->next = NULL;
pPrev = pHead;
//--------------------
while (1)
{
scanf("%d",&v_NodeData);
if (v_NodeData!=-1)   //将v_NodeData值插入到新增结点上
{
//malloc a new node
pCurr = (RingNode*)malloc(sizeof(RingNode));//返回指针型地址值
//store v_NodeData
pCurr->pos = v_NodeData;
//add node's linkship
pPrev->next = pCurr;
pPrev = pCurr;
pCurr->next = NULL;
} 
else                          
{
pPrev->next = pHead->next;      //tail points to the 2nd node.
break;
}
}
//
return pHead;
}
//---------//pHead:约瑟夫环首地址
void DisplayJosephusRing(RingNodePtr pHead)
{   
RingNodePtr pCurr=NULL,pPrev;
pCurr=pHead->next;
pPrev=pHead->next;
//----------链表是否存在？
if(pHead==NULL||pHead->next==NULL)
{
printf("List is empty or none\n");
exit(0);
}
//----------循环单链表结点数据输出方法
while(pCurr->next!=pPrev)    //from the first node loop output pCurr->pos
{
printf("%d->",pCurr->pos);
pCurr=pCurr->next;
}
printf("%d",pCurr->pos);    //pCurr->next==pPrev,此时pCurr为尾结点
printf("\n");
//----------
}
//pHead:约瑟夫环首地址,start:开始报数起点,amount:环的大小,stop:报数上限.
//---------------------------------------------------------------------
void JosephusKickout(RingNodePtr pHead,int start,int amount,int stop)
{  
//约瑟夫环是否存在？
if(pHead==NULL||pHead->next==NULL)
{
printf("JosephusRing is empty or none\n");
exit(0);
}
//停止报数点stop=1吗？
//  if(stop==1)
//  {
//  printf("最后剩下者为最后一个数!\n");
//  exit(0);
//  }
RingNodePtr pCurr=NULL,pPrev=NULL; 
int n;
int temp=0;//temp:start---stop之间的循环临时计数变量
pPrev=pHead;
pCurr=pHead->next;        
n=1;       //此时n用于设置第一个开始报数时的起点位置start
       //************退出循环 时pCurr,pPrev分别位于指定位置start 
while(n++<start)    
{      
pCurr=pCurr->next;        
pPrev=pPrev->next; 
}   
n=1;       
while(n++<amount)    //---O(amount*stop)
{        
temp=1;    //temp作为循环临时变量        
while(temp++<stop)        
{            
pCurr=pCurr->next;            
pPrev=pPrev->next;        
}             

printf("删除结点%d\t",pCurr->pos);        
pPrev->next=pCurr->next;
                free(pCurr);       
pCurr=pPrev->next; 
//-------
if (pPrev==pCurr)
{
printf("\n最后剩下%d\n",pCurr->pos);
free(pCurr);
break;
}
//-------stop=1时输出删除结点顺序表
if ((stop==1)&&(n==amount))
{
printf("\n最后剩下%d\n",pCurr->pos);
free(pCurr);
break;
}


}    
}
//------------------
int Length(RingNodePtr pHead)
{   
if(pHead==NULL) //empty ring exit!
exit(0);
//
int count=1;
//开始循环计数结点，求其长度count.
RingNodePtr pCurr;
pCurr=pHead->next;
while(pCurr->next!=pHead->next)
{
count++;
pCurr=pCurr->next;
}
//exit loop,get count value.
return count;
}

//--------------------------------------测试函数1-----------------------------------------------------

int main()

{

//******************************************************************约瑟夫环创建方法2--带空头结点，stop>=1;

//--根据输入系列元素值自动创建一个约瑟夫环ListRing，计数输入元素个数即链表长度

RingNodePtr ListRing=NULL;
//-------建立约瑟夫循环链表
printf("---------------Auto Build a Josephus Ring---------------\n");
ListRing = CreateJosephesRing();
#ifdef _DEBUG
DisplayJosephusRing(ListRing);
#endif
// 开始出圈
    //------约瑟夫环问题,以l示例
int m_start=0,m_stop=0;
printf("\nPlease input JosephusRing Kickout startpoint and stoppoint!\n");
  scanf("%d,%d",&m_start,&m_stop);
if(m_start <= 0 || m_stop <= 0)
{
printf("Input Error\n");
system("pause");
return 0;
}
printf("startpoint:%d    stoppoint:%d\n",m_start,m_stop);
//------
printf("\n--------------自动创建约瑟夫环时,Josephus out list------------\n");
JosephusKickout(ListRing,m_start,Length(ListRing),m_stop);
printf("\n");
system("pause");
return 0;

}

第二种情况：用户输入M,N值，从1至N开始顺序循环数数，每数到M输出该数值，直至全部输出。写出C程序。（约瑟夫环问题 Josephus）

解法一：最高效算法---只求取最后优胜者算法（转载）

       思想：归纳为数学性问题。原文说的很好，还是直接Copy吧，因为搜索半天也没有找到原作者，所以无法添加引用地址了，如果这位大哥看到这里，请告知与我，小弟立刻加入引用链接:)

无论是用链表实现还是用数组实现都有一个共同点：要模拟整个游戏过程，不仅程序写起来比较烦，而且时间复杂度高达O(nm)，当n，m非常大(例如上百万，上千万)的时候，几乎是没有办法在短时间内出结果的。我们注意到原问题仅仅是要求出最后的胜利者的序号，而不是要读者模拟整个过程。因此如果要追求效率，就要打破常规，实施一点数学策略。

为了讨论方便，先把问题稍微改变一下，并不影响原意：
问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。求胜利者的编号。

我们知道第一个人(编号一定是(m-1)%n) 出列之后--附：原文中参考值为（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     --> 0
k+1   --> 1
k+2   --> 2
...
...
k-2   --> n-2
k-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)

有了这个公式，我们要做的就是从1-n顺序算出f[i]的数值，最后结果是f[n]。因为实际生活中编号总是从1开始，我们输出f[n]+1
由于是逐级递推，不需要保存每个f[i]，程序也是异常简单：

1 #include <stdio.h>
 2 int main()
 3 {
 4     int n, m, i, s = 0;
 5     printf ("N M = ");
 6     scanf("%d%d", &n, &m);
 7     for (i = 2; i <= n; i++)
 8     {
 9         s = (s + m) % i;
10     }
11     printf ("\nThe winner is %d\n", s+1);
12 }

这个算法的时间复杂度为O(n)，相对于模拟算法已经有了很大的提高。算n，m等于一百万，一千万的情况不是问题了。可见，适当地运用数学策略，不仅可以让编程变得简单，而且往往会成倍地提高算法执行效率。

解法二(My Solution)：
      思想：建立一个有N个元素的循环链表，然后从链表头开始遍历并记数，如果计数i==m(i初始为1)踢出元素，继续循环，当当前元素与下一元素相同时退出循环。
代码：

1 /*
  2  约瑟夫环问题(Josephus)
  3  用户输入M,N值，从1至N开始顺序循环数数，每数到M输出该数值，直至全部输出。写出C程序。（约瑟夫环问题 Josephus）
  4  Code By Eric Yang 2009
  5  http://ericyang.cnblogs.com

  6 */
  7 #include <stdio.h>
  8 #include <stdlib.h>
  9 
 10 // 链表节点
 11 typedef struct _RingNode
 12 {
 13     int pos;  // 位置
 14     struct _RingNode *next;
 15 }RingNode, *RingNodePtr;
 16 
 17 // 创建约瑟夫环，pHead:链表头指针，count:链表元素个数
 18 void CreateRing(RingNodePtr pHead, int count)
 19 {
 20     RingNodePtr pCurr = NULL, pPrev = NULL;
 21     int i = 1;
 22     pPrev = pHead;
 23     while(--count > 0)
 24     {
 25         pCurr = (RingNodePtr)malloc(sizeof(RingNode));
 26         i++;
 27         pCurr->pos = i;
 28         pPrev->next = pCurr;
 29         pPrev = pCurr;
 30     }
 31     pCurr->next = pHead;  // 构成环状链表
 32 }
 33 
 34 void PrintRing(RingNodePtr pHead)
 35 {
 36     RingNodePtr pCurr;
 37     printf("%d", pHead->pos);
 38     pCurr = pHead->next;
 39     while(pCurr != NULL)
 40     {
 41         if(pCurr->pos == 1)
 42             break;
 43         printf("\n%d", pCurr->pos);
 44         pCurr = pCurr->next;
 45     }
 46 }
 47 
 48 void KickFromRing(RingNodePtr pHead, int m)
 49 {
 50     RingNodePtr pCurr, pPrev;
 51     int i = 1;    // 计数
 52     pCurr = pPrev = pHead;
 53     while(pCurr != NULL)
 54     {
 55         if (i == m)
 56         {
 57             // 踢出环
 58             printf("\n%d", pCurr->pos);    // 显示出圈循序
 59             pPrev->next = pCurr->next;
 60             free(pCurr);
 61             pCurr = pPrev->next;
 62             i = 1;
 63         }
 64         pPrev = pCurr;
 65         pCurr = pCurr->next;
 66         if (pPrev == pCurr)
 67         {
 68             // 最后一个
 69             printf("\n%d", pCurr->pos);    // 显示出圈循序
 70             free(pCurr);
 71             break;
 72         }
 73         i++;
 74     }
 75 }
 76 
 77 int main()
 78 {
 79     int m = 0, n = 0;
 80     RingNodePtr pHead = NULL;
 81     printf("---------------Josephus Ring---------------\n");
 82     printf("N(person count) = ");
 83     scanf("%d", &n);
 84     printf("M(out number) = ");
 85     scanf("%d", &m);
 86     if(n <= 0 || m <= 0)
 87     {
 88         printf("Input Error\n");
 89         system("pause");
 90         return 0;
 91     }
 92     // 建立链表
 93     pHead = (RingNodePtr)malloc(sizeof(RingNode));
 94     pHead->pos = 1;
 95     pHead->next = NULL;
 96     CreateRing(pHead, n);
 97 #ifdef _DEBUG
 98     PrintRing(pHead);
 99 #endif
100 
101     // 开始出圈
102     printf("\nKick Order: ");
103     KickFromRing(pHead, m);    
104     printf("\n");
105     system("pause");
106     return 0;
107 }
108