Question

我正在努力帮助某人编写一个我认为很容易的程序，当然它永远不会是：）

我正在尝试上一个班级名单（通常在10到20名学生之间），并且有效地将每个同学与另一个同学配对，以制作独特的团体。因此，在一个10人的班级中，你可以有9个小组。

它也需要能够处理奇数的学生，这增加了我的困惑。

我正在考虑用Java做这个，但这很灵活。关于算法的任何想法，以保证a）不是无限循环（以2个已经成为合作伙伴的人结束）和b）我的目标是比空间更有效率，因为班级规模会很小！

谢谢！

Answer 1

您希望创建一个完整的图表，将每个学生作为一个节点，然后随机选择边缘并将它们插入一个唯一的集合中。

在下一个“拉动”中，你想要做同样的事情，除非现在已经选择了边缘，丢弃并重新选择。

Answer 2

这对我来说是一个不寻常的答案 - 说“下载一个应用程序” - 但是你去了：

你描述的内容可能与国际象棋锦标赛配对相似。

检查出来：http://home.swipnet.se/rullchef/chessp/

这是Monrad系统的解释，可能就是你所追求的：

Monrad System

Monrad系统是杯系统的一个非常有趣的变体，据我所知，它只在国际象棋比赛中定期使用。在第一轮中，所有球队都是随机配对的。获胜者得1分，宽松零。在每个连续的回合中，具有相同点数的所有队伍被随机配对（除了先前已经相互比赛的队伍如果存在其他配对可能性则不能配对）。与杯系统相比，这个系统具有所有球队继续比赛的优势，并且随着赛季（或锦标赛）的进步，具有相同实力的球队将相互会面。可以播放的轮数没有限制，但如果团队有相似但不一定相同的点数，最终必须配对。在预定义的一组轮次之后具有最大分数的团队是胜利者。

Answer 3

以上是Vlion上面回答的伪代码。这不是最快的方法，但它是概念的一个例证（感谢Vlion！）

// create all the edges
for i := 1 to number_of_students - 1
  for j := i + 1 to number_of_students
    edges.add(new Edge(i,j))

// select all groups from the edges
for x := 1 to number_of_students - 1
  used_nodes.clear
  group.clear

  for y := 1 to number_of_students div 2
    do
      current_edge = edges.get_next
    while (current_edge.n1 not in used_nodes) and
          (current_edge.n2 not in used_nodes)

    used_nodes.add(current_edge.n1)
    used_nodes.add(current_edge.n2)

    group.add(current_edge)

    edges.remove(current_edge)

  groups.add(group)

Answer 4

这是解决问题的C＃代码。

我认为你真的关心最大化学生配对的独特性，而不是一组可能独特的学生配对。

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;

namespace Pairing
{
    class Program
    {
        static void Main(string[] args)
        {
            //switch these lines if you'd prefer a command line interface to a text file.
            var rgs = File.ReadAllLines("Roster.txt");
            //var rgs = args;

            var setPairs = new HashSet<HashSet<string>>();
            for (var ixrgs = 0; ixrgs < rgs.Length - 1; ixrgs++)
                for (var ixrgsSubset = ixrgs + 1; ixrgsSubset < rgs.Length; ixrgsSubset++)
                    setPairs.Add(new HashSet<string>(new string[] { rgs[ixrgs], rgs[ixrgsSubset] }));

            var setGroups = new HashSet<HashSet<HashSet<string>>>();
            var setUsedPairs = new HashSet<HashSet<string>>();
            while (setPairs.Count > 0)
            {
                var setPairsTmp = new HashSet<HashSet<string>>(setPairs);
                var setTmp = new HashSet<HashSet<string>>();
                var setUsedVariables = new HashSet<string>();

                while (setPairsTmp.Count > 0)
                {
                    //give me the first element
                    var pair = setPairsTmp.First<HashSet<string>>();
                    //store it
                    setTmp.Add(pair);
                    //add it to our set of used variables
                    setUsedVariables.UnionWith(pair);
                    //remove it from our set of available pairs.
                    setPairsTmp.RemoveWhere(set => set.Intersect<string>    (setUsedVariables).Count<string>() != 0);

                    //remove its implicated deadlocks from our set of available pairs
                    //(this step is both gross, and key. Without it, failure potential arises.)
                        var s1 = new HashSet<string>();
                        var s2 = new HashSet<string>();
                        //get the set of variables paired with the first:
                        var rgPair = pair.ToArray<string>();
                        foreach (var set in setUsedPairs)
                        {
                            if (set.Contains(rgPair[0]))
                                s1.UnionWith(set);
                            if(set.Contains(rgPair[1]))
                                s2.UnionWith(set);
                        }
                        s1.IntersectWith(s2);
                        //enumerate the pairs created by the deadlocking pairs, remove them from our available selections.
                        var rgsTmp = s1.ToArray<string>();
                        for (var ixrgs = 0; ixrgs < rgsTmp.Length - 1; ixrgs++)
                            for (var ixrgsSubset = ixrgs + 1; ixrgsSubset < rgsTmp.Length; ixrgsSubset++)
                                setPairsTmp.RemoveWhere(set => set.Contains(rgsTmp[ixrgs]) && set.Contains(rgsTmp[ixrgsSubset]));
                }
                setPairs.ExceptWith(setTmp);
                setGroups.Add(setTmp);
                setUsedPairs.UnionWith(setTmp);
            }
            //at this point, setGroups contains the set of unique group combinations.
            //the non-maximally sized groups indicate unique sets that could form provided that
            //all other students are in redundant sets.

            var enumerableGroups = setGroups.OrderByDescending<HashSet<HashSet<string>>, int>(set => set.Count);
            //Sanity Check:
            foreach (var group in enumerableGroups)
            {
                Console.Write("{");
                foreach (var pair in group)
                    Console.Write(string.Format(@"[{0},{1}]", pair.ToArray<string>()));
                Console.WriteLine("}");
            }
        }
    }
}

Answer 5

您要求的算法似乎与为循环赛锦标赛准备计划的算法大致相同。详细信息可在this Wikipedia article中找到。您还可以使用网络上的发电机进行快速试用。其中一个可以找到here。

Answer 6

我不知道它是否正是您要的，但是在这里，我用简单的python进行了研究。它吐出了您可以为10个学生组成的每个唯一分组。

我猜这不是最快的事情，但它很容易实现和遵循。

from itertools import permutations

def my_sort(x):
    assert type(x) in (tuple, list)
    assert len(x)==10
    groups = x[0:2],x[2:4],x[4:6],x[6:8],x[8:10]
    groups = sorted([sorted(g) for g in groups], key=lambda k:k[0])
    return tuple(x  for g in groups for x in g )

S = set(my_sort(p) for p in permutations(list(range(10))))

"""
len(S) == 945
list(sorted(S))[-3:] == [(0, 9, 1, 8, 2, 7, 3, 4, 5, 6), (0, 9, 1, 8, 2, 7, 3, 5, 4, 6), (0, 9, 1, 8, 2, 7, 3, 6, 4, 5)]
"""

元组代表一行中的所有组：（0、9、1、8、2、7、3、4、5、6）表示0与9分组，1与8分组，依此类推。

分组算法

6 个答案: