Java 在相同大小的存储桶中生成非重复对
我有一个从这个代码生成的对的列表Java 在相同大小的存储桶中生成非重复对,java,algorithm,Java,Algorithm,我有一个从这个代码生成的对的列表 int n = listTeam.size(); for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { if (i != j) listTeamPairs.add(new Team[] { listTeam.get(i), listTeam.get(j) }); } } } 我面临的问题是将这些对挑选成大
int n = listTeam.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (i != j)
listTeamPairs.add(new Team[] { listTeam.get(i), listTeam.get(j) });
}
}
}
0-1, 2-3, 4-5
0-2, 1-3 <- swap order of these matches.
This leaves only team 4-5 again. Which is not valid.
0-2,1-3 p[0].getName（）.contentEquals（team1.getName（））|
p[1].getName（）.contentEquals（team2.getName（））|| p[0].getName（）.contentEquals（team2.getName（））||
p[1].getName（）.contentEquals（team1.getName（））.findAny（）；
if（t.isPresent（））
返回false；
roundTeams.add（teamInRound）；
TMP移除（组队环绕）；
返回true；
}
专用void生成器unds（列表团队）{
对于（int i=0；iSystem.out.println（p[0].getName（）+“-”+p[1].getName（））；
如果（i==0）{
teams.add（tmpTeamPairs.get（0））；
tmpTempairs.remove（0）；
持续
}
对于（团队[]对：tmpTeamPairs）{
布尔b=生成循环（成对，团队）；
如果（b）{
打破
}
}
}
}
scheduled team 0 against team 4
scheduled team 2 against team 3 <-----
scheduled team 5 against team 1
Array order
0
2 <---
5
4
3 <---
1
Lag 5 - Lag3
Lag1 - Lag2 <-----
Lag4 - Lag 6
-----------------------------------------------
scheduled team 0 against team 5
scheduled team 1 against team 4
scheduled team 2 against team 3 <----
Array order
0
1
2 <---
5
4
3 <---
Lag 5 - Lag4
Lag 6 - Lag3
Lag1 - Lag2 <-----
预定的0队对4队
预定的第2队对第3队你想要实现的是制定一个比赛计划，包括回合。这可以使用循环调度算法来完成
这是通过修复一个竞争对手来实现的，比如0。其余部分将顺时针旋转以生成新组合
实现这一点的代码可以如下所示：
public static void generateRoundRobinPairs(List<Integer> teams) {
Integer fixedElement = teams.get(0);
List<Integer> teamsWithoutFirst = teams.subList(1,teams.size());
for (int i = 0; i < teamsWithoutFirst.size(); i++) {
List<Integer> toSchedule = new ArrayList<>();
toSchedule.add(fixedElement);
teamsWithoutFirst = buildNewRotation(teamsWithoutFirst);
toSchedule.addAll(teamsWithoutFirst);
scheduleRound(toSchedule);
}
}
public static void scheduleRound(List<Integer> teams) {
for (int i = 0; i < teams.size() / 2; i++) {
// here create your data structure
String template ="scheduled team %s against team %s";
System.out.println(String.format(template, teams.get(i), teams.get(i + teams.size() / 2)));
}
}
public static List<Integer> buildNewRotation(List<Integer> l) {
List<Integer> newList = new ArrayList<>();
newList.add(l.get(l.size() / 2));
for (int i = 0; i < l.size() / 2 - 1; i++) {
newList.add(l.get(i));
}
for (int i = 0; i < l.size() / 2; i++) {
newList.add(l.get(i + 1 + l.size() / 2));
}
newList.add(l.get(l.size() / 2 - 1));
return newList;
}
publicstaticvoidgenerateroundrobinpairs（列表团队）{
整数fixedElement=teams.get（0）；
List teamsWithoutFirst=teams.subList（1，teams.size（））；
对于（int i=0；i
下面是循环调度的另一个实现
它返回成对存储桶的列表。虽然您可以创建一个自定义类，但pair只是通过列表实现的
每个bucket都是一个集合
，因为只要团队配对已知，bucket中的顺序就无关紧要
计划本身是一个列表
，因为顺序在计划中很重要
该方法是通用的，因此您可以将其作为Integer
或String
放入团队中，以查看它是否工作正常，或者使用一个成熟的Team
类
public static <T> List<Set<List<T>>> roundRobin(List<T> teams) {
int numTeams = teams.size();
// For a proper league, we only allow even number of teams.
if ( numTeams % 2 != 0 ) {
throw new IllegalArgumentException("Number of teams not even " + numTeams);
}
List<Set<List<T>>> result = new ArrayList<>(numTeams - 1);
// Implement the round robin by rotating the right side of the list
// every time, then pairing opposite teams. Note that the first
// item is not part of the rotation.
for ( int i = 0; i < numTeams - 1; i++ ) {
Collections.rotate(teams.subList(1,numTeams), 1);
Set<List<T>> bucket = new HashSet<>();
for ( int j = 0; j < numTeams / 2; j++ ) {
bucket.add(Arrays.asList(teams.get(j), teams.get(numTeams - j - 1)));
}
result.add(bucket);
}
return result;
}
结果：
[West Ham Utd., Liverpool]
[Chelsea, Tottenham]
[Manchester Utd., Arsenal]
[Manchester Utd., Liverpool]
[Arsenal, Tottenham]
[West Ham Utd., Chelsea]
[Liverpool, Chelsea]
[Manchester Utd., Tottenham]
[Arsenal, West Ham Utd.]
[Liverpool, Arsenal]
[Tottenham, West Ham Utd.]
[Manchester Utd., Chelsea]
[Manchester Utd., West Ham Utd.]
[Tottenham, Liverpool]
[Chelsea, Arsenal]
致：
Set pair=Arrays.asList（teams.get（j），teams.get（numTeams-j-1））；
如果（i%2==1&&j==0）{
收藏。反面（成对）；
}
bucket.add（成对）；
不相关，但是如果（i！=j）
似乎不需要。如果i=j，球队会自己比赛。当然，但是你已经用来说明这一点了（int j=i+1；…
已经开始了。你是在寻找任何分为两轮的分区？还是随机的分区？@realpoint any会这样做…事实上早在你看到5-3将出现在前两轮时就打了电话：计划0队对2队计划5队对3队计划1队对4队计划0队对1队sc计划的第4队对第2队计划的第5队对第3队没有帮助发送[0,1,2,5,4,3]中的数组。
public static <T> List<Set<List<T>>> roundRobin(List<T> teams) {
int numTeams = teams.size();
// For a proper league, we only allow even number of teams.
if ( numTeams % 2 != 0 ) {
throw new IllegalArgumentException("Number of teams not even " + numTeams);
}
List<Set<List<T>>> result = new ArrayList<>(numTeams - 1);
// Implement the round robin by rotating the right side of the list
// every time, then pairing opposite teams. Note that the first
// item is not part of the rotation.
for ( int i = 0; i < numTeams - 1; i++ ) {
Collections.rotate(teams.subList(1,numTeams), 1);
Set<List<T>> bucket = new HashSet<>();
for ( int j = 0; j < numTeams / 2; j++ ) {
bucket.add(Arrays.asList(teams.get(j), teams.get(numTeams - j - 1)));
}
result.add(bucket);
}
return result;
}
List<String> teams = Arrays.asList(
"Manchester Utd.",
"Chelsea",
"Tottenham",
"Liverpool",
"Arsenal",
"West Ham Utd." );
for ( Set<List<String>> bucket : roundRobin(teams)) {
for ( List<String> pair : bucket) {
System.out.println(pair);
}
System.out.println();
}
[West Ham Utd., Liverpool]
[Chelsea, Tottenham]
[Manchester Utd., Arsenal]
[Manchester Utd., Liverpool]
[Arsenal, Tottenham]
[West Ham Utd., Chelsea]
[Liverpool, Chelsea]
[Manchester Utd., Tottenham]
[Arsenal, West Ham Utd.]
[Liverpool, Arsenal]
[Tottenham, West Ham Utd.]
[Manchester Utd., Chelsea]
[Manchester Utd., West Ham Utd.]
[Tottenham, Liverpool]
[Chelsea, Arsenal]
bucket.add(Arrays.asList(teams.get(j), teams.get(numTeams - j - 1)));
Set<List<T>> pair = Arrays.asList(teams.get(j), teams.get(numTeams - j - 1));
if ( i % 2 == 1 && j == 0 ) {
Collections.reverse(pair);
}
bucket.add(pair);