约瑟夫环

参考链接：https://blog.csdn.net/OKasy/article/details/79503398

题目：

 Josephus有过的故事：39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓。于是决定了自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀。然后下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。

对于这个题目大概两种解法：

一、使用循环链表模拟全过程

1. #include<iostream>

2.  

3. using namespace std;

4.  

5. /************约瑟夫问题****************/

6.  

7. typedef struct CLinkList

8. {

9. int data;

10. struct CLinkList *next;

11. }node;

12.  
13.  

14. int main()

15. {

16. ///建立循环链表

17. node *L,*r,*s;

18. L = new node;

19. r =L;

20. int n = 41,i;

21. int k = 3;

22. for(i = 1;i<=n;i++) //尾插法建立链表

23. {

24. s = new node;

25. s->data = i;

26. r->next = s;

27. r= s;

28. }

29. r->next =L->next; //让最后一个结点指向第一个有数据结点

30. node *p;

31. p = L->next;

32. delete L; //删除第一个空的结点

33.  

34. ///模拟解决约瑟夫问题

35. while(p->next != p) //判断条件：因为最后肯定剩下一个人， 循环链表的最后一个数据的next还是他本身

36. {

37. for(i = 1;i<k-1;i++)

38. {

39. p = p->next; //每k个数死一个人

40. }

41. cout<<p->next->data<<"->";

42. p->next = p->next->next; //将该节点从链表上删除。

43. p = p->next;

44. }

45. cout<<p->data<<endl;

46. return 0;

47. }

二、公式法

    我们假设这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。

8、这下看出来规律了把：

我们是正着推的，如果反过来推导，每次剩下的人的编号为f(i)，剩一个人的时候编号一定为0，两个人为0,1，以此类推，则利用以下公式可以推导出每次剩下的人。

1. f(1)=0;

2. f(i)=(f[i-1]+m)%i;(i>1)

代码如下：

1. #include<iostream>

2.  

3. using namespace std;

4.  

5. ///推导公式方法

6. int yuesefu(int n,int m){

7.         if(n == 1){

8.                 return 0; //这里返回下标,从0开始，只有一个元素就是剩余的元素0

9.         }

10.         else{

11.                 return (yuesefu(n-1,m) + m) % n; //我们传入的n是总共多少个数

12.         }

13. }

14. int main(void){

15.  

16.         int a=41,b=3;

17.         //递归求最后一个存活的编号

18.         //使用从正向思考

19.         cout<<"最后一个人是"<<yuesefu(a,b)+1<<endl;

20.  

21.         //反向思考，从自杀的最后一人向前

22.         int result = 2;

23.         //第一个自杀的人3号

24.         cout<<3;

25.         //每次自杀的都是2号，但是不同的2号换算到最初序号所需的的次数是不同的

26.         //外循环是循环不同的换算次数

27.         for(int i = a; i >= 2 ; i-- )

28.         {

29.             result = 2;

30.             //内循环是开始换算

31.             for(int j = i; j <= a; j++)

32.             {

33.                 result = (result+b) %j;

34.             }

35.                cout<<"->"<<result+1;//0开始变1开始，所以加1

36.         }

37.         return 0;

38. }

39.  

结果是一样的：