约瑟夫环问题的具体描述是:设有编号为1,2,……,n的n(n>0)个人围成一个圈,从第1个人开始报数,报到m时停止报数,报m的人出圈,再从他的下一个人起重新报数,报到m时停止报数,报m的出圈,……,如此下去,直到所有人全部出圈为止。
解法一(My Solution):
思想:建立一个有N个元素的循环链表,然后从链表头开始遍历并记数,如果计数i==m(i初始为1)踢出元素,继续循环,当当前元素与下一元素相同时退出循环。
#include <stdio.h>
#include <stdlib.h>
// 链表节点
typedef struct _RingNode
{
int pos; // 位置
struct _RingNode *next;
}RingNode, *RingNodePtr;
// 创建约瑟夫环,pHead:链表头指针,count:链表元素个数
void CreateRing(RingNodePtr pHead, int count)
{
RingNodePtr pCurr = NULL, pPrev = NULL;
int i = 1;
pPrev = pHead;
while(--count > 0)
{
pCurr = (RingNodePtr)malloc(sizeof(RingNode));
i++;
pCurr->pos = i;
pPrev->next = pCurr;
pPrev = pCurr;
}
pCurr->next = pHead; // 构成环状链表
}
void PrintRing(RingNodePtr pHead)
{
RingNodePtr pCurr;
printf("%d", pHead->pos);
pCurr = pHead->next;
while(pCurr != NULL)
{
if(pCurr->pos == 1)
break;
printf("\n%d", pCurr->pos);
pCurr = pCurr->next;
}
}
void KickFromRing(RingNodePtr pHead, int m)
{
RingNodePtr pCurr, pPrev;
int i = 1; // 计数
pCurr = pPrev = pHead;
while(pCurr != NULL)
{
if (i == m)
{
// 踢出环
printf("\n%d", pCurr->pos); // 显示出圈循序
pPrev->next = pCurr->next;
free(pCurr);
pCurr = pPrev->next;
i = 1;
}
pPrev = pCurr;
pCurr = pCurr->next;
if (pPrev == pCurr)
{
// 最后一个
printf("\n%d", pCurr->pos); // 显示出圈循序
free(pCurr);
break;
}
i++;
}
}
int main()
{
int m = 0, n = 0;
RingNodePtr pHead = NULL;
printf("---------------Josephus Ring---------------\n");
printf("N(person count) = ");
scanf("%d", &n);
printf("M(out number) = ");
scanf("%d", &m);
if(n <= 0 || m <= 0)
{
printf("Input Error\n");
system("pause");
return 0;
}
// 建立链表
pHead = (RingNodePtr)malloc(sizeof(RingNode));
pHead->pos = 1;
pHead->next = NULL;
CreateRing(pHead, n);
#ifdef _DEBUG
PrintRing(pHead);
#endif
// 开始出圈
printf("\nKick Order: ");
KickFromRing(pHead, m);
printf("\n");
system("pause");
return 0;
}
解法二(From Net):
思想:归纳为数学性问题。原文说的很好,还是直接Copy吧,因为搜索半天也没有找到原作者,所以无法添加引用地址了,如果这位大哥看到这里,请告知与我,小弟立刻加入引用链接:)无论是用链表实现还是用数组实现都有一个共同点:要模拟整个游戏过程,不仅程序写起来比较烦,而且时间复杂度高达O(nm),当n,m非常大(例如上百万,上千万)的时候,几乎是没有办法在短时间内出结果的。我们注意到原问题仅仅是要求出最后的胜利者的序号,而不是要读者模拟整个过程。因此如果要追求效率,就要打破常规,实施一点数学策略。
为了讨论方便,先把问题稍微改变一下,并不影响原意:
问题描述: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 --> 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)
先总结一下约瑟夫环的递推公式:
f[1]=0; f[i]=(f[i-1]+m)%i; (i>1)
f[1]=1; f[i]=(f[i-1]+m)%i (i>1); if(f[i]==0) f[i]=i;
P(1, m, k)=1 (i = 1); P(i, m, k)=[P(i - 1, m, k ) + m - 1] % i + 1 (i > 1, 此处先减1是为了让模i的值不为0)
那么这三个公式有什么不同?
首先可以肯定的是这三个公式都正确。公式1,得到的是以0~n-1标注的最终序号;公式2,3得到的就是正常的1~n的序号;并且公式2和公式3其实是一个意思。下面我们就分别推导三个公式,并且推导的过程中,你也就能明白这三个公式的共同点和不同点。
公式1的推导:——————————
给出一个序列,从0~n-1编号。其中,k代表出列的序号的下一个,即k-1出列。
a 0, 1, …, k-1, k, k+1, …, n-1
那么,出列的序号是(m-1)%n,k=m%n(这个可真的是显而易见)。出列k-1后,序列变为
b 0, 1, …, k-2, k, k+1, …, n-1
然后,我们继续从n-1后延长这个序列,可以得到
c` 0, 1, …, k-2, k, k+1, …, n-1, n, n+1, …, n+k-2
我们取从k开始直到n+k-2这段序列。其实这段序列可以看作将序列b的0~k-2段移到了b序列的后面。这样,得到一个新的序列
c k, k+1, …, n-1, n, n+1, …, n+k-2
好了,整个序列c都减除一个k,得到
d 0, 1, …, n-2
c序列中的n-1, n, n+1都减除个k是什么?这个不需要关心,反正c序列是连续的,我们知道了头和尾,就能知道d序列是什么样的。
这样你看,从序列a到序列d,就是一个n序列到n-1序列的变化,约瑟夫环可以通过递推来获得最终结果。ok,继续向下。
剩下的就是根据n-1序列递推到n序列。假设在n-1序列中,也就是序列d中,我们知道了最终剩下的一个序号是x,那么如果知道了x转换到序列a中的编号x`,不就是知道了最终的结果了么?
下面我们就开始推导出序列a中x的序号是什么。
d->c,这个变换很容易,就是x+k;
c->b,这个变换是网上大家都一带而过的,也是令我郁闷的一个关键点。从b->c,其实就是0~k-2这段序列转换为n~n+k-2这段序列,那么再翻转回去,简单的就是%n,即(x+k)%n。%n以后,k~n-1这段序列值不会发生变化,而n~n+k-2这段序列则变成了0~k-2;这两段序列合起来,就是序列b。
于是乎,我们就知道了,x`=(x+k)%n。并且,k=m%n,所以x`=(x+m%n)%n=(x+m)%n。公式1就出来了:f[i]=(f[i-1]+m)%i。当然,i=1就是特殊情况了,f[1]=0。这里还有一个小问题。也许你会迷惑为什么x`=(x+m%n)%n=(x+m)%n中的%n变成公式中f[i]=(f[i-1]+m)%i中的%i?其实这个稍微想想就能明了。我们%n就是为了从序列c转换到序列b——这是在n-1序列转换成n序列时%n;那么从n-2转换到n-1呢?不是要%(n-1)了吗?所以这个值是变量,不是常量。
好了,这个最后需要注意的就是从一开始,我们将n序列从0~n-1编号,所以依据公式1得出的序号是基于0开始的。
有了这个公式,我们要做的就是从1-n顺序算出f[i]的数值,最后结果是f[n]。因为实际生活中编号总是从1开始,我们输出f[n]+1
由于是逐级递推,不需要保存每个f[i],程序也是异常简单:
#include <stdio.h>
int main()
{
int n, m, i, s = 0;
printf ("N M = ");
scanf("%d%d", &n, &m);
for (i = 2; i <= n; i++)
{
s = (s + m) % i;
}
printf ("\nThe winner is %d\n", s+1);
}
解法三:
思路非常简单,按模来找到要删除得位置,但是,主要到下标从0开始和数字从1开始是有一些不一样得,另外,py的del后,下标会增1,所以要减回去。
正确看是
del link[ind-1]
ind-=1
但是,因为两者都需要后退1,所以直接ind-=1就OK了。
另外要主要得是,来到环尾部,即py的-1(这点就是最好的地方,py得tuple 和list 支持负下标),删除后,开始就要变成0
def josephus(n,k):
link=range(1,n+1)
ind=0
for loop_i in range(n-1):
ind = (ind+k)% len(link)
ind-=1
print 'Kill:',link[ind]
del link[ind]
if ind==-1: # the last element of link
ind=0
print 'survice :',link[0]
if __name__ == '__main__':
josephus(100000,300)
print '-'*30
josephus(10,5)
print '-'*30
josephus(10,1)
解法四:循环队列:
#include<stdio.h>
#define MAX 100
int front=MAX-1;
int rear=MAX-1;
void enqueue(int q[],int x)//入队算法
{
rear=(rear+1)%MAX;
q[rear]=x;
}
int dequeue(int q[])//出队算法
{
front=(front+1)%MAX;
return q[front];
}
int main()
{
int m,i,n;
int q[MAX],k=0,y;
scanf("%d%d",&m,&n);
for(i=1;i<=m;i++)
enqueue(q,i);
while(front!=rear)
{
y=dequeue(q);
k++;
if(k%n==0)
continue;
else
enqueue(q,y);
}
printf("%d\n",y);
return 0;
}
转载:http://www.cnblogs.com/EricYang/archive/2009/09/04/1560478.html
http://hi.baidu.com/anywei/item/294351b5f432f144ba0e12f2
http://blog.csdn.net/dengyaolongacmblog/article/details/39208675