约瑟夫环问题求解
约瑟夫问题
约瑟夫问题是个著名的问题: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 ->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)