Algorithm 如何开发开发人员审阅队列轮换的算法？

假设您有开发人员

A

，

B

，

C

，

D

，

E

，

F

，他们会互相检查工作

您如何开发一种算法来生成评审轮换，告诉每个开发人员他们每周必须评审哪些工作，并满足以下标准：

• 您不能连续两周查看同一个人
• 不能有闭环（

  A

  reviews

  B

  ，

  B

  reviews

  A

  ）
• 如果在开始重复之前，您能互相回顾一下开发人员，那就太好了

---

我想我可以和奇数个开发者一起工作，但我正在为偶数的开发者而奋斗。

我会走nieve路线，在一个圆形数组中旋转。因此，第1周，每个人都会对右边的人进行回顾+0。第2周，每个人都会回顾右边的人+1。第三周，右+2，等等

Week 1:
  A -> B
  B -> C
  ...
  F -> A
Week 2:
  A -> C
  B -> D
  ...
  F -> B

---

这是哈斯凯尔的一支蛮力（大约需要10秒的时间）

代码：

我假设通过闭合循环，你指的是长度正好为2的循环。也就是说，允许

A

审查

B

，

B

审查

C

和

C

审查

A

让

n

为人数，让

0，…，n-1

为姓名

第1周： Person

i

查看Person

（i+1）%n的代码

第2周：个人
i
查看个人
（i+2）%n的代码


周
n/2
：个人
i
无法查看个人
（i+n/2）%n的代码，因为这将导致闭环。因此，person
i
会检查person
（i+n/2+1）%n的代码

周
n/2+1
：个人
i
查看个人的代码
（i+n/2+2）%n


周
n-1
：Person
i
查看Person
（i+1）%n
再次，一切重新开始

注意：您的最后一个（可选）要求（每个人在循环再次开始前审查其他人）被违反。对于
n=2
和
n=4
，无论如何都不存在满足所有要求的解决方案。基本情况
n=2
微不足道。考虑下面的代码<代码> n＝4 < /代码>：如果你想避免关闭循环，至少有一个人必须连续两次查看同一个人。（只需列举所有可能的审查关系即可看到这一点）

如果您确实需要最后一个需求，那么您必须使用@groovy的解决方案。我把我的留在这里，因为它很容易计算。
不需要重复就可以得到所有可能的对

Arrange developers in two columns, left column reviews right one.
Fix A place
Move all others in cyclic way.

A->F
B->E 
C->D

A->B
C->F 
D->E

A->C
D->B 
E->F

A->D
E->C 
F->B

A->E
F->D 
B->C

我似乎从循环轮换中找到了一个解决方案

对于开发者
A
，
B
，
C
，
D
，
E
，
F

你可以修复一个开发者，比如说
a
。然后顺时针旋转其余部分

然后：


第一排的每个人都会评论他们下面的人
坐在最下面一排的每个人都要回顾一下上面和右边对角线上的人

第一周：

A B C
D E F

AD
BE
CF
DB
EC
FA

A D B
E F C

AE
DF
BC
ED
FB
CA

A E D
F C B

AF
EC
DB
FE
CD
BA

A F E
C B D

AC
FB
ED
CF
BE
DA

A C F
B D E

AB
CD
FE
BC
DF
EA

第2周：

A B C
D E F

AD
BE
CF
DB
EC
FA

A D B
E F C

AE
DF
BC
ED
FB
CA

A E D
F C B

AF
EC
DB
FE
CD
BA

A F E
C B D

AC
FB
ED
CF
BE
DA

A C F
B D E

AB
CD
FE
BC
DF
EA

第3周：

A B C
D E F

AD
BE
CF
DB
EC
FA

A D B
E F C

AE
DF
BC
ED
FB
CA

A E D
F C B

AF
EC
DB
FE
CD
BA

A F E
C B D

AC
FB
ED
CF
BE
DA

A C F
B D E

AB
CD
FE
BC
DF
EA

第4周：

A B C
D E F

AD
BE
CF
DB
EC
FA

A D B
E F C

AE
DF
BC
ED
FB
CA

A E D
F C B

AF
EC
DB
FE
CD
BA

A F E
C B D

AC
FB
ED
CF
BE
DA

A C F
B D E

AB
CD
FE
BC
DF
EA

第5周：

A B C
D E F

AD
BE
CF
DB
EC
FA

A D B
E F C

AE
DF
BC
ED
FB
CA

A E D
F C B

AF
EC
DB
FE
CD
BA

A F E
C B D

AC
FB
ED
CF
BE
DA

A C F
B D E

AB
CD
FE
BC
DF
EA

尽管它仍然显示出一些不需要的特性，有些人永远不会遇到其他人，例如
B
避免
D
使用
ROT13
作为灵感。或者更确切地说，
ROT1
，
ROT2
，…为了增加随机化，在随机排序的初始集上使用
ROT
（即，代替ABCDEF，使用它的一些排列作为初始集）。@G.Bach随机化给算法带来了什么好处？@GavinMiller mdobrinin没有要求任何东西，但是如果他们不想在循环中进行检查，他们可以使用它。我不确定
ROT13
是否会满足不可能有闭合循环的属性。参见Gavin Miller的答案，它本质上是不起作用的ROT1。参见第3周：
A
reviews
D
，
D
reviews
A
@mdobrinin：然而，如果你愿意放弃你的一个需求（参见我的答案），这个方案可以很容易地修复。开发人员将在整个星期内审查同一个人。我的意思是，同时，您正在审阅的人不能审阅您。那么输出示例是否提供了您要求的内容？（这只是五周列表流中的第一个。）五周内：连续两周没有对同一个人的评论，没有闭合循环，每个开发人员都会被评论一次。结果是这样的，但我更多的是寻找一个简单的算法，而不是暴力程序。这不是一个理论上的问题，因此解决方案必须易于复制<代码>A->F
表示
A
审核
F
和
F
审核
A
？这违反了要求。@mdobrinin不，我们可以使用旋转（循环）的右列作为左列的审阅者。这似乎与Gavin Miller的回答相同，因为您只跳过了有问题的几周。@mdobrinin:确实如此。我写了一个单独的答案，因为我想明确假设，并显示接受/离开可选需求之间的权衡。