Algorithm 生成奇偶圈的算法？

我正在尝试制作一个程序（带有GUI），它将解析文本文件输入，并创建一个“奇偶校验圈”

举个简单的例子，假设Aaron、Bob和Chuck正在玩石头剪刀，并且：

• 亚伦打败鲍勃
• 鲍勃打败了查克
• 查克打败亚伦

然后，奇偶圈就存在了：Aaron>Bob>Chuck>Aaron（并重复）。通过（不合逻辑的）归纳推理，可以说鲍勃在《石头剪纸》方面比亚伦强，尽管鲍勃输给了亚伦

但是，如果：

• 亚伦打败鲍勃
• 鲍勃输掉了所有比赛
• 查克打败亚伦

那么就不存在奇偶圈了。每个人必须至少有一场胜利和一场失败，才能存在一个完整的平价循环。因此，在我看来，从赢/输最少的个人/团队/节点开始分析似乎是合乎逻辑的

最后，如果：

• 艾伦打败了鲍勃和查克
• 鲍勃输掉了所有比赛
• 查克击败鲍勃和艾伦

然后存在一个不完整的奇偶校验循环：Aaron>Chuck>Aaron

---

在我的计划中，每个团队/个人都会有一份其击败的所有团队的列表，并且该计划将处理大量团队（30+），因此效率总是很高的。我还可以实现一个它输给的所有团队的列表。关于如何实现一个算法来遍历这些列表，有什么建议吗？提前谢谢

我认为这是一个问题，目前还没有已知的有效算法。对于小图，回溯搜索可能是可行的。有一个动态编程解决方案，理论上比回溯搜索快——但是这只是从O（n）到O（n ^ 2×2 ^ n）

< p>的变化，只是为了好玩，考虑一下这个…（免责声明：时间不早了，我只是想集思广益：-）

我正在努力用图论解决这个问题。
假设您确实构建了一个捕获每个游戏的图表。
您将如何遍历它以生成分数？
您必须跟踪每个玩家得分的“访问”列表，递归城市。
看起来你必须对每个玩家进行彻底的遍历。
O（哎哟）

所以。。。告诉我这是否合理：

Example Games:
A/B: winner.A
B/C: winner.B
C/A: winner.C

explicit (using vict since same # letters as loss):
A.vict.B   B.loss.A
B.vict.C   C.loss.B
C.vict.A   A.loss.C

Breaking all these out:
:   raw     : simple sort  :
: A.vict.B  : A.loss.C     :
: B.loss.A  : A.vict.B     :
: B.vict.C  : B.loss.A     :
: C.loss.B  : B.vict.C     :
: C.vict.A  : C.loss.B     :
: A.loss.C  : C.vict.A     :


Grouped by loss vs. vict:
A:  loss[ C ]   vict [ B ]
B:  loss[ A ]   vict [ C ]
C:  loss[ B ]   vict [ A ]

为了给你的球员排名。。。
从他们的净胜利开始怎么样

在上面的例子中，每个人都有一个零净赢，所以所有人都一样强（或弱）

或者，每个玩家可以选择一个winLossRatio，而不是净赢。上述示例中的所有玩家的比率为0.5（例如，1胜/2场总游戏）。
然后根据对手的实力生成一个加权WinLoss，其中你的积分为赢（和输）

当SQL更新数据库表时，这样做可能更好。。。
但下面是伪java中的想法示意图

Class Player {
   //something to track all players.
   //and I suppose to load their wins & losses.
   static updateScores() {
      foreach player ( players ) {
         player.updateWinLossRatio();
      }
      // have to update ratios before computing scores using those ratios.
      foreach player ( players ) {
         player.updateWeightedScores();
      }
   }
   updateWinLossRatio() {
      // want #wins / totalGames
      winLossRatio = victories.size() / (victories.size() + losses.size() );
      // add check for zero and stuff.
   }
   updateWeightedScore() {
      weightedWinLoss = 0;
      foreach opponent ( victories ) {
         weightedWinLoss += opponent.winLossRatio;
         // this sort of already reduces credit for weak opponents,
         // since their win ratio would be pretty small.
      }
      foreach opponent ( losses ) {
         weightedWinLoss -= opponent.winLossRatio;
         // might want to penalize by inverse of opponents strength.
         // e.g. losing to a super weak opponent should hurt more.
         // so maybe:
         //    weightedWinLoss -= 1 / opponent.winLossRatio;
      }
   }
}

---

如果我这样做的话，我想在我的测试数据上运行一些公式，绘制结果曲线并调整它，直到它看起来合理为止。您可能需要调整您的分数，如果将该比率计算为log（wins）/log（totalgames）或其他值，您可能会感觉更好。

堆栈溢出是您可以询问编码问题的地方-您在代码方面有一个特殊问题，请将其粘贴到此处，开发人员将帮助您解决该问题。这并不是像你所问的那样的“告诉我如何做xyz”。