Java生成随机游戏者对

我的问题是生成具有相同游戏数的随机玩家对，但限制游戏数，以便所有玩家不必彼此玩

把它想象成一场国际象棋游戏，随机玩家被设置为游戏，但每个玩家不必与所有玩家一起玩（这将花费太多时间），但他们都必须有相同数量的游戏才能公平竞争

到目前为止，我为游戏生成了一个独特的配对，但所有的玩家都必须和每个人玩，这花费了太多的时间。 我知道代码并不漂亮，但它必须每月运行一次，以生成对：

    @RequestMapping("/voistlus/{id}")
    public String newGame(Model model, @PathVariable Long id) {
    Stage stage = stageService.findOneById(id);
    if (gameService.findByStage(stage).isEmpty()) {
        List<Paar> paars = paarService.getAllPaar();
        List<Game> pairs = new ArrayList<Game>();
        for (Paar one : paars) {
            for (Paar two : paars) {
                if (!one.equals(two)) {
                    Game newPair = new Game();
                    newPair.setPaar1(one);
                    newPair.setPaar2(two);
                    if (!pairs.contains(newPair)) {
                        if (pairs.isEmpty()) {
                            pairs.add(newPair);
                            newPair.setStage(stage);
                            gameService.save(newPair);
                        } else {
                            boolean exists = false;
                            for (Game game : pairs) {
                                if (game.getPaar1().equals(two) && game.getPaar2().equals(one)) {
                                    exists = true;
                                }
                            }
                            if (!exists) {
                                pairs.add(newPair);
                                newPair.setStage(stage);
                                gameService.save(newPair);
                            }
                        }
                    }
                }
            }
        }
    }
    model.addAttribute("pairs", gameService.findByStage(stage));
    return "newGame";
}

@RequestMapping（“/voistlus/{id}”）
公共字符串newGame（模型模型，@PathVariable长id）{
Stage Stage=stageService.findOneById（id）；
if（gameService.findByStage（stage.isEmpty（））{
List paars=paarService.getAllPaar（）；
列表对=新的ArrayList（）；
适用于（PaarOne:paars）{
用于（Paar二：Paar）{
如果（！1.等于（2））{
Game newPair=新游戏（）；
新配对。setPaar1（一个）；
新配对。setPaar2（两个）；
如果（！pairs.contains（newPair））{
if（pairs.isEmpty（））{
pairs.add（newPair）；
新对。设置阶段（阶段）；
gameService.save（newPair）；
}否则{
布尔存在=假；
用于（游戏：双人）{
if（game.getPaar1（）等于（2）和&game.getPaar2（）等于（1））{
存在=真；
}
}
如果（！存在）{
pairs.add（newPair）；
新对。设置阶段（阶段）；
gameService.save（newPair）；
}
}
}
}
}
}
}
model.addAttribute（“pairs”，gameService.findByStage（stage））；
返回“新游戏”；
}

迭代游戏数量，每次随机挑选玩家如何

    int numberOfGames = 10;
    List<Paar> paars = paarService.getAllPaar();
    for (int game = 0; game < numberOfGames; game++) {
        // for each "game day", shuffle the list of players
        Collections.shuffle(paars);
        for (int playerIndex = 0; playerIndex < paars.size(); playerIndex+=2) {
            Game newPair = new Game();
            newPair.setStage(stage);
            newPair.setPaar1(paars.get(playerIndex));
            newPair.setPaar2(paars.get(playerIndex+1));
            gameService.save(newPair);
        }
    }

int numberOfGames=10；
List paars=paarService.getAllPaar（）；
for（int game=0；game

---

不利的一面是，你无法避免同一对玩家之间的多次对抗

考虑一个图，其中每个玩家都是一个顶点，玩家之间的边表示这些玩家之间的游戏。我们要做的是在这个图中找到圈，每个圈都经过所有参与者，也就是说，我们要在这个图中找到哈密顿圈

一般来说，确定一个图是否有哈密顿圈是NP完全的。然而，由于在这个问题中我们考虑的图是一个完整的图（每个顶点彼此有一个顶点），这个问题是很容易的。 我们可以使用以下伪代码来实现这一点

Let V be the empty set
Let E be the empty set

Let init be a random vertex
Add init to V

While V does not contain all players
    Select a random vertex R that is not in V
    Add R to V
    Add the edge (init - R) to E
    Let init = R
End

E now contains the set of games to be played

通过多次这样做，您将能够生成多个哈密顿循环，每个循环都是一组游戏，其中每个玩家正好与另外两个不同的玩家进行游戏

这种算法有一个主要缺点，那就是它允许同一个游戏发生多次。（有可能玩家1和玩家2必须进行多次比赛。）

如果我们想避免这种情况，我们必须在搜索下一个循环之前从图中删除找到的循环。然而，这样做使得确定是否还有另一个循环，从而找到它，再次成为NP完全

---

如果你想解决这个问题，一个很好的起点应该是和。

将其视为哈密顿循环问题非常尖锐。阶段是比赛的一部分