问题描述
有m张卡片，编号从1到m，每张卡片都有一个唯一的编号。卡片被分发给坐在一个圆圈里的 n 个人。请注意 m >= n。
然后我们选择坐在位置“p”的人“A”离开圆圈，就像约瑟夫斯问题一样。下一步，我们跳过 p 右边的“k”个人，而 k 是“A”人所标记的牌号，我们做同样的事情，直到圆圈中只剩下一个人。
问题给了n个人和m张牌，我们可以选择n张牌分配给n个人，使得无论从哪个位置开始（不包括第一个位置），最后生存的人总是第一个圈子里的人。
例如，m = n = 5，唯一的解是 (4,1,5,3,2)。
我认为这个问题是一个np-complete问题，但我无法证明。任何人都有找到多项式时间解决方案或证明它是 np-hard 的好主意吗？
--- 示例解决方案 ---
2: [ 1,2]
2: [ 2,1]
3: [ 1,2]
3: [ 3,2]
4: [ 4,2]
5: [ 4,2]
7: [ 5,7,6,4,2]
9: [ 2,9,8,4]
9: [ 3,2,8]
9: [ 3,2]
9: [ 3,8]
9: [ 6,2]
10: [ 3,10,2]
10: [ 4,3]
10: [ 5,4]
10: [ 6,2]
10: [ 8,3]
10: [10,4]
11: [ 2,11,4]
11: [ 3,2]
11: [ 3,6]
11: [ 4,8]
11: [ 4,2]
11: [ 4,8]
11: [ 5,2]
11: [ 6,4]
11: [ 6,8]
11: [ 6,8]
11: [ 9,4]
12: [ 1,12,3]
12: [ 3,8]
12: [ 3,6]
12: [ 4,2]
12: [ 5,4]
12: [ 5,8]
12: [ 5,3]
12: [ 7,4]
12: [ 8,2]
12: [ 8,2]
12: [12,8]
13: [ 2,13,9]
13: [ 2,10]
13: [ 2,6]
13: [ 3,8]
13: [ 3,10]
13: [ 4,8]
13: [ 6,2]
13: [ 6,4]
13: [ 6,3]
13: [ 7,6]
13: [ 7,12]
13: [ 7,10]
13: [ 7,8]
13: [ 8,2]
13: [ 8,2]
13: [ 9,8]
13: [ 9,6]
13: [ 9,2]
13: [10,2]
13: [11,8]
13: [11,12]
13: [11,8]
13: [12,2]
13: [12,8]
13: [13,2]
14: [ 3,14,12]
14: [ 3,6]
14: [ 4,3]
14: [ 4,8]
14: [ 5,3]
14: [ 6,10]
14: [ 6,10]
14: [ 7,3]
14: [ 7,12]
14: [ 7,6]
14: [ 8,6]
14: [11,9]
14: [11,6]
14: [12,8]
14: [12,10]
14: [12,2]
14: [13,12]
14: [13,8]
14: [14,12]
14: [14,10]
--- 可能有助于数学解决方案--- 我注意到从长度 9 开始，每个长度至少有一个解决方案有一个很长的整数序列，递减 1。
9: [3,8]
10: [6,2]
11: [3,2]
11: [3,6]
11: [5,2]
12: [4,6]
12: [4,2]
13: [6,2]
14: [3,2]
解决方法
我注意到，对于我测试的每个长度，除了非常小的，至少有一个解决方案包含相对较长的下降运行 数字。到目前为止，这个答案只考虑了 m = n。这里有一些例子;请注意，多余的是 n - run_len：
n = 3,run_len = 2,excess = 1: [1] + [3-2] + []
n = 4,excess = 2: [4,1] + [3-2] + []
n = 5,excess = 3: [4,1,5] + [3-2] + []
n = 6,no solution
n = 7,run_len = 1,excess = 6: [5] + [7-7] + [3,6,4,2]
n = 8,no solution
n = 9,run_len = 3,excess = 6: [3,2] + [7-5] + [9,8]
n = 10,run_len = 4,excess = 6: [6,3,1] + [10-7] + [4,5,2]
n = 11,excess = 7: [3,7] + [11-8] + [1,2]
n = 12,excess = 8: [4,2,1] + [11-8] + [12,7,6]
n = 13,run_len = 5,excess = 8: [6,13,1] + [12-8] + [3,2]
n = 14,run_len = 7,14,1] + [12-6] + [4,2]
n = 15,run_len = 8,15,2] + [13-6] + [1,14]
n = 16,run_len = 6,excess = 10: [6,10] + [16-11] + [2,9,8]
n = 17,excess = 9: [2,17,1] + [13-6] + [4,16]
n = 18,run_len = 10,18,1] + [16-7] + [5,2]
n = 19,excess = 9: [4,19,2]
n = 20,no solution found with run_length >= 10
n = 21,run_len = 14,21,2] + [19-6] + [1,20]
n = 22,excess = 8: [22,1] + [20-7] + [5,6]
n = 23,excess = 9: [7,23,3] + [21-8] + [6,22,2]
n = 24,run_len = 16,24,2] + [22-7] + [3,4]
n = 25,run_len = 17,excess = 8: [25,1] + [23-7] + [5,6]
n = 26,excess = 9: [26,25,6]
n = 27,run_len = 20,27,2] + [25-6] + [1,26]
n = 28,run_len = 18,excess = 10: [28,3] + [25-8] + [6,26]
n = 29,29,26,1] + [25-6] + [4,28]
n = 30,run_len = 23,excess = 7: [30,1] + [28-6] + [29,4]
n = 31,run_len = 24,excess = 7: [5,31,3] + [29-6] + [1,30,2]
n = 32,32,1] + [30-8] + [5,6]
n = 33,run_len = 26,33,2] + [31-6] + [1,32]
n = 34,run_len = 27,34,1] + [32-6] + [4,2]
n = 35,excess = 8: [5,35,2]
n = 36,excess = 10: [35,36,2] + [34-9] + [6,8]
n = 37,run_len = 29,1] + [35-7] + [36,37,4]
n = 38,excess = 9: [3,38,1] + [36-8] + [6,2]
n = 39,run_len = 32,39,2] + [37-6] + [1,38]
n = 40,run_len = 31,excess = 9: [5,1] + [38-8] + [3,40,39]
n = 41,run_len = 33,excess = 8: [3,2] + [38-6] + [41,4]
n = 42,excess = 9: [42,41,1] + [39-7] + [5,6]
n = 43,run_len = 34,excess = 9: [6,43,1] + [41-8] + [42,2]
n = 44,run_len = 35,1] + [42-8] + [43,44,6]
n = 45,run_len = 38,45,2] + [43-6] + [1,44]
n = 50,run_len = 43,excess = 7: [50,1] + [48-6] + [49,4]
n = 100,run_len = 91,1] + [98-8] + [3,100,99]
n = 201,run_len = 194,201,2] + [199-6] + [1,200]
上表中缺少 20，因为运行长度最多为 10，并且需要很长时间来计算。我测试过的较大值的最大运行长度相对于 n。
我通过从 n-1 降序检查运行长度，以及运行和周围元素的所有可能的起始值和排列来找到这些。这极大地减少了搜索空间。
对于给定的 n，如果 n 的任何解中的最大运行长度为 n-k，那么这将在 O(k! * n) 中找到它。虽然这看起来很糟糕，但如果 k 有一个恒定的上限（例如，对于所有足够大的 n，k
更新：这里有很多模式。
如果 n mod 6 是 3 并且 n >= 9，那么 [3,n,[n-2,n-3,...,6],n-1] 是有效。
如果 n mod 12 是 5 并且 n >= 17 那么 [2,n-2,[n-4,n-5,n-1] 有效。
如果 n mod 20 是 10，那么 [n,n-1,4] 是有效的。
如果 n mod 60 是 7、11、31 或 47，则 [5,2 ] 有效。
如果 n mod 60 是 6 或 18 并且 n >= 18 那么 [6,7],2] 有效。
如果 n mod 60 是 1,25 或 52 并且 n >= 22 那么 [n,1],n -1,6] 有效。
如果 n mod 60 是 23，那么 [7,8],2] 是有效的。
如果 n mod 60 是 14 或 34，则 [3,2] 是有效的。>
如果 n mod 60 是 24 那么 [6,4] 是有效的
如果 n mod 60 是 2,42 并且 n >= 26 那么 [n,[n-3,n-4,6] 有效。
如果 n mod 60 是 16 或 28 那么 [n,n -2] 有效。
如果 n mod 60 是 32，那么 [7,6] 是有效的。
如果 n mod 60 是 35 或 47 那么 [5,2] 是有效。
如果 n mod 60 是 37 那么 [6,4]
如果 n mod 60 是 38 那么 [3,1] + [n-2,8] + [6,2]
如果 n mod 60 是 40，那么 [5,n-1] 是有效的
如果 n mod 60 是 0 并且 n >= 60 那么 [3,4]有效
如果 n mod 60 是 7、19 或 31 并且 n >= 19 那么 [4,2] 有效
如果 n mod 60 是 23、38 或 43，则 [7,2] 是一个有效的解决方案
如果 n mod 60 是 14 或 44 并且 n >= 74 那么 [3,2] 有效。
如果 n mod 60 是 1 或 49 并且 n >= 49 那么 [3,6] 有效。
如果 n mod 60 是 6、18、30、42 或 54 并且 n >= 18 那么 [n,6] 有效。
如果 n mod 60 是 10,38 或 58 并且 n >= 18 那么 [n-1,3] 有效。
目前为 n mod 60 求解的是以下任意值：
0,10,11,16,28,42,47,49,50,51,52,53,54,57,58
还有，
如果 n mod 42 是 31，那么 [n,6] 是有效的。
如果 n mod 420 是 36 或 396 那么 [n-1,9],8 ] 有效。
--- n=21 的示例，使用上面列出的第一个模式和所有起始索引。
1: [21,12,8,20,1]
2: [ 2,7]
3: [19,1]
4: [18,6]
5: [17,1]
6: [16,6]
7: [15,1]
8: [14,6]
9: [13,1]
10: [12,6]
11: [11,1]
12: [10,6]
13: [ 9,1]
14: [ 8,6]
15: [ 7,1]
16: [ 6,2]
17: [ 1,21]
18: [ 5,21]
19: [ 4,1]
20: [20,2]
对于该模式适用的所有 n 值，您可以观察到递减运行中的元素与其他元素之间的相同关系。这不是证明，但您可以将其转化为证明，尽管我认为需要为每个模式单独完成这项工作，这超出了我将花时间用于 S/O 的范围问题。
--- 我们可以用 m > n 来填空。 ---
模式 [n-1,3],n+5] 对 n mod 4 为 1 且 n >= 9 有效。>
模式 [n,n+4] 对 n mod 2 为 0 且 n >= 6 有效。
有了这两个，再加上我们已经找到的东西，我们几乎可以得到一切。我通过检查有限范围内的单个替换值找到了这些。
0,46,48,56,58
如果 n mod 30 是 29，那么 [3,4],n+15) 是有效的，给我们 n mod 60是 59。我们只剩下一个未知数：n mod 60 是 55。
...终于！如果 n mod 12 是 7（即 n mod 60 是 7、19、31、43 或 55），则 [n-1,n+4] 对所有 n >= 19 都有效。
我们现在有所有 n mod 60 的解决方案，在大多数情况下使用 m=n，在最坏情况下使用 m=n+15。