约瑟夫环问题求解
约瑟夫问题
约瑟夫问题是个著名的问题：N个人围成一圈，第一个人从1开始报数，报M的将被杀掉，下一个人接着从1开始报。如此反复，最后剩下一个，求最后的胜利者。
例如只有三个人，把他们叫做A、B、C，他们围成一圈，从A开始报数，假设报2的人被杀掉。
- 首先A开始报数，他报1。侥幸逃过一劫。
- 然后轮到B报数，他报2。非常惨，他被杀了
- C接着从1开始报数
- 接着轮到A报数，他报2。也被杀死了。
- 最终胜利者是C
求解
数组
我们可以直接用数组去模拟这个过程，遍历，代码如下，过程比较直观，注释辅助阅读
1 n, m = map(int, input().strip().split()) 2 3 a = [0] * (n + 1) 4 5 # cnt记录当前出局人数，i 用来记录数组中元素的位置， k用来记录本局游戏中报数 6 cnt, i, k = 0, 0, 0 7 8 while cnt != n: 9 i += 1 10 11 # 避免数据越界，重新开始 12 if i > n: 13 i = 1 14 15 if a[i] == 0: 16 k += 1 17 if k == m: 18 a[i] = 1 # 已经出局，标记为1 19 k = 0 # k重新开始计数 20 cnt += 1 # 出局人数加一 21 22 # 打印出局人位置 23 print(i) # 位置从1开始 24 # print(i - 1) # 位置从0开始
链表
除了数组，我们可以用链表的方法去模拟这个过程，N个人看作是N个链表节点，节点1指向节点2，节点2指向节点3，……，节点N-1指向节点N，节点N指向节点1，这样就形成了一个环。然后从节点1开始1、2、3……往下报数，每报到M，就把那个节点从环上删除。下一个节点接着从1开始报数。最终链表仅剩一个节点。它就是最终的胜利者。
1 class ListNode: 2 def __init__(self, val=0, next=None): 3 self.val = val 4 self.next = next 5 6 7 def list(): 8 head = ListNode(1) 9 p = head 10 i = 2 11 12 while i <= n: 13 node = ListNode(i) 14 p.next = node 15 p = node 16 i += 1 17 18 p.next = head 19 20 p = head # p指向头结点 21 r = ListNode() # 保存p的前一个节点 22 while p.next != p: 23 for i in range(1, m): 24 r = p 25 p = p.next 26 print(p.val) 27 r.next = p.next 28 p = p.next 29 30 print(p.val) # 输出最后一个节点 31 32 33 if __name__ == '__main__': 34 n, m = map(int, input().strip().split()) 35 list()
缺点：
要模拟整个游戏过程，时间复杂度高达O(nm)，当n，m非常大(例如上百万，上千万)的时候，几乎是没有办法在短时间内出结果的。
递归
首先从特例开始体会这个问题
特例：m = 2
当m = 2时候，是一个特例，能快速求解
即使是特例2 ，也有两种情况，
情况一：n 为2的倍数， n = 2^k
如果只有2个人，显然剩余的为1号
如果有4个人，第一轮除掉2,4，剩下1,3，3死，留下1
如果是8个人，先除去2,4,6,8,之后3,7，剩下1,5，除去5，又剩下1了
定义J(n)为n个人构成的约瑟夫环最后结果，
J(n) = 2^k - 2^k-1 = 2^k-1 n=2^k
J(n) = 2^k-1 - 2^k-2 = 2^k-2 n=2^k-1
………
J(2^2) = 2^2 - 2^1 = 2^1 n=2^2
递推得到如上结果，起始我们仔细分析也就是每次除去一半的元素，然后剩余的一半继续重复之前的策略，再除去一半。（可想到递归）结合：J(2) = 1 我知道两个数，从1开始，肯定是2先死，剩下1.
得到：j(2^k) = 1
情况二：n 不为2的倍数， n = 2^k+t
当n不为2的倍数，如 n = 2^k+t 时， 容易想到，当剔除了t个元素以后，就形成了上述的情况一，例如
假设n = 11，这时候n = 2^3 + 3，也就是说t = 3，所以开始剔除元素直到其成为2^k问题的约瑟夫问题。
So，我们在剔除了t（3）个元素之后（分别是2,4,6），此时我们定格在2t+1（7）处，并且将2t+1（7）作为新的一号，而且这时候的约瑟夫环只剩下2^3，也就是J(2^3 + 3) = 2*3 + 1 = 7，答案为7
总结一下这个规律：J(2^k + t) = 2t+1
一般解法
当q ≠ 2：
我们假定：
- n — n人构成的约瑟夫环
- m — 每次移除第m个人
-
约定：
- Jm(n)表示n人构成的约瑟夫环，每次移除第m个人的解
- n个人的编号从0开始至n-1
我们沿用之前特例的思想：能不能由Jm(n+1)的问题缩小成为J(n)的问题（这里的n是n+1规模的约瑟夫问题消除一个元素之后的答案），Jm(n)是在Jm(n+1)基础上移除一个人之后的解。也就是说，我们能由Jm(n)得到Jm(n+1)。
规律：Jm(n+1) = ( Jm(n) + m ) / (n+1)
推导过程：
初始情况： 0, 1, 2 ......n-2, n-1 (共n个人)
第一个人(编号一定是(m-1)%n,设之为(k-1) ,读者可以分m<n和m>=n的情况分别试下，就可以得出结论) 出列之后，剩下的n-1个人组成了一个新的约瑟夫环（以编号为k==m%n的人开始）:
k k+1 k+2 ... n-2, n-1, 0, 1, 2, ...,k-3, k-2
现在我们把他们的编号做一下转换：
x' -> x
k --> 0
k+1 --> 1
k+2 --> 2
...
...
k-2 --> n-2
k-1 --> n-1
变换后就完完全全成为了(n-1)个人报数的子问题，假如我们知道这个子问题的解：例如x是最终的胜利者，那么根据上面这个表把这个x变回去不刚好就是n个人情况的解吗！
x ->ｘ＇？(这正是从n-1时的结果反过来推n个人时的编号！)
0 -> k
1 -> k+1
2 -> k+2
...
...
n-2 -> k-2
变回去的公式 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] + k ) % i = ( f[i-1] + m % i) % i = ( f[i-1] + m ) % i ; (i>1)
代码
1 # 递归 2 def josephus(n, m): 3 if n == 1: 4 return 0 5 return (josephus(n - 1, m) + m) % n 6 7 8 # 迭代 9 def josephus_2(n, m): 10 res = 0 11 for i in range(2, n + 1): 12 res = (res + m) % i 13 return res 14 15 16 if __name__ == '__main__': 17 print(josephus(10, 3) + 1) 18 print(josephus_2(11, 3) + 1)
