Question

假设我有两个列表，如何遍历每个子列表的每个可能组合，这样每个项目只出现一次。

我想一个例子可能是你有员工和工作，你想把他们分成团队，每个员工只能在一个团队中，每个工作只能在一个团队中。例如

List<string> employees = new List<string>() { "Adam", "Bob"}  ;
List<string> jobs      = new List<string>() { "1", "2", "3"};

我想要

Adam       : 1
Bob        : 2 , 3

Adam       : 1 , 2
Bob        : 3

Adam       : 1 , 3
Bob        : 2

Adam       : 2 
Bob        : 1 , 3

Adam       : 2 , 3
Bob        : 1

Adam       : 3
Bob        : 1 , 2

Adam, Bob  : 1, 2, 3

我尝试使用this stackoverflow问题的答案来生成每个可能的员工组合和每个可能的工作组合的列表，然后从每个列表中选择一个项目，但这就是我得到。

我不知道列表的最大大小，但肯定会小于100，并且可能还有其他限制因素（例如每个团队的员工人数不得超过5人）

更新

不确定这是否可以更多和/或简化，但这是我到目前为止所得到的。

它使用了Yorye提供的Group算法（参见下面的答案），但我删除了不需要的orderby，如果键不可比较会导致问题。

var employees = new List<string>() { "Adam", "Bob"  } ;
var jobs      = new List<string>() { "1", "2", "3"  };

int c= 0;
foreach (int noOfTeams in Enumerable.Range(1, employees.Count))
{   
    var hs = new HashSet<string>();

    foreach( var grouping in Group(Enumerable.Range(1, noOfTeams).ToList(), employees))
    {   
        // Generate a unique key for each group to detect duplicates.   
        var key = string.Join(":" , 
                      grouping.Select(sub => string.Join(",", sub)));           

        if (!hs.Add(key))
            continue;

        List<List<string>> teams = (from r in grouping select r.ToList()).ToList();

        foreach (var group in Group(teams, jobs))
        {
            foreach (var sub in group)
            {               
                Console.WriteLine(String.Join(", " , sub.Key )   + " : " + string.Join(", ", sub));
            }
            Console.WriteLine();
            c++;
        }
    }

}           
Console.WriteLine(String.Format("{0:n0} combinations for {1} employees and {2} jobs" , c , employees.Count, jobs.Count));

由于我并不担心结果的顺序，这似乎给了我所需要的东西。

Answer 1

好问题。

首先，在编写代码之前，让我们了解问题的基本组合。

基本上，对于集合A的任何分区，您需要在集合B中需要相同数量的部分。

E.g。如果将A组拆分为3组，则需要将B组拆分为3组，如果您不至少有一个元素在另一组中没有相应的组。
使用拆分集A到1组可以更容易地对其进行描绘。我们必须在示例中使用集合B创建一个组（Adam，Bob：1,2,3）。

现在，我们知道集合A具有 n 元素，集合B具有 k 元素。
所以很自然地，我们不能要求任何集合被分割为Min(n,k)。

我们假设我们将两个集合分成两组（分区），现在我们在两组之间有1*2=2!个唯一对。另一个例子是3组，每组将给我们1*2*3=3!个唯一对
但是，在将任何集合拆分为多个子集（组）之后，我们仍然没有完成，我们仍然可以按多种组合对元素进行排序。
因此，对于集合中的m个分区，我们需要找到在n分区中放置m个元素的组合数量。
这可以通过使用第二个的斯特林数来找到亲切的公式：

（公式1） Stirling Number of the Second Kind

此公式为您提供了将一组n元素划分为k非空集的方式的数量。

因此，从1到min(n,k)的所有分区的对的组合总数为：

（公式2） All combinations

简而言之，它是两个集合的所有分区组合的总和，乘以所有对的组合。

现在我们了解如何对数据进行分区和配对，我们可以编写代码：

<强>代码：

所以基本上，如果我们看一下最后的等式（2），我们就会明白我们需要四个代码来解决问题。
1.求和（或循环）
2.从两组中获取斯特林组或分区的方法
3.获得斯特林集合的笛卡尔积的方法。
4.一种置换一组物品的方法。（N！）

在StackOverflow上，您可以找到许多方法来了解如何获取项目以及如何查找笛卡尔积，这是一个示例（作为扩展方法）：

 public static IEnumerable<IEnumerable<T>> Permute<T>(this IEnumerable<T> list)
    {
        if (list.Count() == 1)
            return new List<IEnumerable<T>> { list };

        return list.Select((a, i1) => Permute(list.Where((b, i2) => i2 != i1)).Select(b => (new List<T> { a }).Union(b)))
                   .SelectMany(c => c);
    }

这是代码的简单部分更困难的部分（imho）是找到一组中所有可能的n分区所以为了解决这个问题，我首先解决了如何找到集合中所有可能分区的更大问题（不仅仅是大小为n）。

我想出了这个递归函数：

public static List<List<List<T>>> AllPartitions<T>(this IEnumerable<T> set)
    {
        var retList = new List<List<List<T>>>();

        if (set == null || !set.Any())
        {
            retList.Add(new List<List<T>>());
            return retList;
        }
        else
        {
            for (int i = 0; i < Math.Pow(2, set.Count()) / 2; i++)
            {
                var j = i;

                var parts = new [] { new List<T>(), new List<T>() };


                foreach (var item in set)
                {
                    parts[j & 1].Add(item);
                    j >>= 1;
                }

                foreach (var b in AllPartitions(parts[1]))
                {
                    var x = new List<List<T>>();

                    x.Add(parts[0]);

                    if (b.Any())
                        x.AddRange(b);

                    retList.Add(x);
                }
            }
        }
        return retList;
    }

返回值：List<List<List<T>>>仅表示所有可能分区的列表，其中分区是集合列表，集合是元素列表。
我们不必在此处使用类型列表，但它简化了索引。

现在让我们把所有东西放在一起：

主要代码

//Initialize our sets
        var employees = new [] { "Adam", "Bob" };
        var jobs = new[] {  "1", "2", "3" };

        //iterate to max number of partitions (Sum)
        for (int i = 1; i <= Math.Min(employees.Length, jobs.Length); i++)
        {
            Debug.WriteLine("Partition to " + i + " parts:");

            //Get all possible partitions of set "employees" (Stirling Set)
            var aparts = employees.AllPartitions().Where(y => y.Count == i);
            //Get all possible partitions of set "jobs" (Stirling Set)
            var bparts = jobs.AllPartitions().Where(y => y.Count == i);

            //Get cartesian product of all partitions 
            var partsProduct = from employeesPartition in aparts
                      from jobsPartition in bparts
                               select new {  employeesPartition,  jobsPartition };

            var idx = 0;
            //for every product of partitions
            foreach (var productItem in partsProduct)
            {
                //loop through the permutations of jobPartition (N!)
                foreach (var permutationOfJobs in productItem.jobsPartition.Permute())
                {
                    Debug.WriteLine("Combination: "+ ++idx);

                    for (int j = 0; j < i; j++)
                    {
                        Debug.WriteLine(productItem.employeesPartition[j].ToArrayString() + " : " + permutationOfJobs.ToArray()[j].ToArrayString());
                    }
                }
            }
        }

<强>输出：

Partition to 1 parts:
Combination: 1
{ Adam , Bob } : { 1 , 2 , 3 }
Partition to 2 parts:
Combination: 1
{ Bob } : { 2 , 3 }
{ Adam } : { 1 }
Combination: 2
{ Bob } : { 1 }
{ Adam } : { 2 , 3 }
Combination: 3
{ Bob } : { 1 , 3 }
{ Adam } : { 2 }
Combination: 4
{ Bob } : { 2 }
{ Adam } : { 1 , 3 }
Combination: 5
{ Bob } : { 3 }
{ Adam } : { 1 , 2 }
Combination: 6
{ Bob } : { 1 , 2 }
{ Adam } : { 3 }

我们可以通过计算结果轻松检查我们的输出。
在这个例子中，我们有一组2个元素，以及一组3个元素，等式2表明我们需要S（2,1）S（3,1）1！+ S（2,2）S（3,2））2！ = 1 + 6 = 7
这正是我们得到的组合数。

此处参考的是第二类斯特林数的例子：
S（1,1）= 1

S（2,1）= 1
S（2,2）= 1

S（3,1）= 1
S（3,2）= 3
S（3,3）= 1

S（4,1）= 1
S（4,2）= 7
S（4,3）= 6
S（4,4）= 1

编辑19.6.2012

public static String ToArrayString<T>(this IEnumerable<T> arr)
    {
        string str = "{ ";

        foreach (var item in arr)
        {
            str += item + " , ";
        }

        str = str.Trim().TrimEnd(',');
        str += "}";

        return str;
    }

编辑24.6.2012

这个算法的主要部分是找到斯特林集，我使用了一个无效的置换方法，这里是一个基于QuickPerm算法的更快的方法：

public static IEnumerable<IEnumerable<T>> QuickPerm<T>(this IEnumerable<T> set)
    {
        int N = set.Count();
        int[] a = new int[N];
        int[] p = new int[N];

        var yieldRet = new T[N];

        var list = set.ToList();

        int i, j, tmp ;// Upper Index i; Lower Index j
        T tmp2;

        for (i = 0; i < N; i++)
        {
            // initialize arrays; a[N] can be any type
            a[i] = i + 1; // a[i] value is not revealed and can be arbitrary
            p[i] = 0; // p[i] == i controls iteration and index boundaries for i
        }
        yield return list;
        //display(a, 0, 0);   // remove comment to display array a[]
        i = 1; // setup first swap points to be 1 and 0 respectively (i & j)
        while (i < N)
        {
            if (p[i] < i)
            {
                j = i%2*p[i]; // IF i is odd then j = p[i] otherwise j = 0

                tmp2 = list[a[j]-1];
                list[a[j]-1] = list[a[i]-1];
                list[a[i]-1] = tmp2;

                tmp = a[j]; // swap(a[j], a[i])
                a[j] = a[i];
                a[i] = tmp;

                //MAIN!

               // for (int x = 0; x < N; x++)
                //{
                //    yieldRet[x] = list[a[x]-1];
                //}
                yield return list;
                //display(a, j, i); // remove comment to display target array a[]

                // MAIN!

                p[i]++; // increase index "weight" for i by one
                i = 1; // reset index i to 1 (assumed)
            }
            else
            {
                // otherwise p[i] == i
                p[i] = 0; // reset p[i] to zero
                i++; // set new index value for i (increase by one)
            } // if (p[i] < i)
        } // while(i < N)
    }

这将把时间缩短一半但是，大多数CPU周期都用于字符串构建，这是本例中特别需要的这将使它更快一点：

             results.Add(productItem.employeesPartition[j].Aggregate((a, b) => a + "," + b) + " : " + permutationOfJobs.ToArray()[j].Aggregate((a, b) => a + "," + b));

在x64中进行编译会更好，因为这些字符串占用了大量内存。

Answer 2

你可以使用另一个图书馆吗？ Here是一个通用的组合库（你显然希望这个组合没有重复）。然后，您只需要对员工列表进行预测并运行两者的组合。

我不认为你从大O角度做任何好处，效率是否优先考虑？

这是来自时尚，但这应该是获得你想要的代码（使用该库）：

Combinations<string> combinations = new Combinations<string>(jobs, 2);

foreach(IList<string> c in combinations) {
  Console.WriteLine(String.Format("{{{0} {1}}}", c[0], c[1]));
}

然后需要将其应用于每位员工

Answer 3

在我的回答中，我将忽略您的最后结果： Adam, Bob: 1, 2, 3 ，因为它在逻辑上是一个例外。跳到最后查看我的输出。

<强>解释

这个想法将迭代“元素属于哪一组”的组合。

假设您有元素“a，b，c”，并且您有组“1,2”，让我们有一个大小为3的数组，作为元素的数量，它将包含组的所有可能组合“1 ，2“，重复：

{1, 1, 1} {1, 1, 2} {1, 2, 1} {1, 2, 2}
{2, 1, 1} {2, 1, 2} {2, 2, 1} {2, 2, 2}

现在我们将采用每个组，并使用以下逻辑从中进行键值收集：

elements[i]组将是comb[i]的值。

Example with {1, 2, 1}:
a: group 1
b: group 2
c: group 1

And in a different view, the way you wanted it:
group 1: a, c
group 2: b

毕竟，您只需要过滤掉所有不包含所有组的组合，因为您希望所有组都至少有一个值。

因此，您应检查所有群组是否以特定组合显示并过滤掉不匹配的群组，因此您将留下：

{1, 1, 2} {1, 2, 1} {1, 2, 2}
{2, 1, 2} {2, 2, 1} {2, 1, 1}

这将导致：

1: a, b
2: c

1: a, c
2: b

1: a
2: b, c

1: b
2: a, c

1: c
2: a, b

1: b, c
2: a

这种打破群组的组合逻辑也适用于更多的元素和组。这是我的实现，可能会做得更好，因为即使我在编码时有点迷失（这真的不是一个直观的问题），但是效果很好。

<强>实施

public static IEnumerable<ILookup<TValue, TKey>> Group<TKey, TValue>
    (List<TValue> keys,
     List<TKey> values,
     bool allowEmptyGroups = false)
{
    var indices = new int[values.Count];
    var maxIndex = values.Count - 1;
    var nextIndex = maxIndex;
    indices[maxIndex] = -1;

    while (nextIndex >= 0)
    {
        indices[nextIndex]++;

        if (indices[nextIndex] == keys.Count)
        {
            indices[nextIndex] = 0;
            nextIndex--;
            continue;
        }

        nextIndex = maxIndex;

        if (!allowEmptyGroups && indices.Distinct().Count() != keys.Count)
        {
            continue;
        }

        yield return indices.Select((keyIndex, valueIndex) =>
                                    new
                                        {
                                            Key = keys[keyIndex],
                                            Value = values[valueIndex]
                                        })
            .OrderBy(x => x.Key)
            .ToLookup(x => x.Key, x => x.Value);
    }
}

<强>用法：

var employees = new List<string>() { "Adam", "Bob"};
var jobs      = new List<string>() { "1", "2", "3"};
var c = 0;

foreach (var group in CombinationsEx.Group(employees, jobs))
{
    foreach (var sub in group)
    {
        Console.WriteLine(sub.Key + ": " + string.Join(", ", sub));
    }

    c++;
    Console.WriteLine();
}

Console.WriteLine(c + " combinations.");

<强>输出：

Adam: 1, 2
Bob: 3

Adam: 1, 3
Bob: 2

Adam: 1
Bob: 2, 3

Adam: 2, 3
Bob: 1

Adam: 2
Bob: 1, 3

Adam: 3
Bob: 1, 2

6 combinations.

<强>更新

组合键组合原型：

public static IEnumerable<ILookup<TKey[], TValue>> GroupCombined<TKey, TValue>
    (List<TKey> keys,
     List<TValue> values)
{
    // foreach (int i in Enumerable.Range(1, keys.Count))
    for (var i = 1; i <= keys.Count; i++)
    {
        foreach (var lookup in Group(Enumerable.Range(0, i).ToList(), keys))
        {
            foreach (var lookup1 in
                     Group(lookup.Select(keysComb => keysComb.ToArray()).ToList(),
                           values))
            {
                yield return lookup1;
            }
        }
    }

    /*
    Same functionality:

    return from i in Enumerable.Range(1, keys.Count)
           from lookup in Group(Enumerable.Range(0, i).ToList(), keys)
           from lookup1 in Group(lookup.Select(keysComb =>
                                     keysComb.ToArray()).ToList(),
                                 values)
           select lookup1;
    */
}

还有一些重复问题，但它会产生所有结果。

我将使用删除重复项作为临时解决方案：

var c = 0;
var d = 0;

var employees = new List<string> { "Adam", "Bob", "James" };
var jobs = new List<string> {"1", "2"};

var prevStrs = new List<string>();

foreach (var group in CombinationsEx.GroupCombined(employees, jobs))
{
    var currStr = string.Join(Environment.NewLine,
                              group.Select(sub =>
                                           string.Format("{0}: {1}",
                                               string.Join(", ", sub.Key),
                                               string.Join(", ", sub))));

    if (prevStrs.Contains(currStr))
    {
        d++;
        continue;
    }

    prevStrs.Add(currStr);

    Console.WriteLine(currStr);
    Console.WriteLine();
    c++;
}

Console.WriteLine(c + " combinations.");
Console.WriteLine(d + " duplicates.");

<强>输出：

Adam, Bob, James: 1, 2

Adam, Bob: 1
James: 2

James: 1
Adam, Bob: 2

Adam, James: 1
Bob: 2

Bob: 1
Adam, James: 2

Adam: 1
Bob, James: 2

Bob, James: 1
Adam: 2

7 combinations.
6 duplicates.

注意它还会产生非组合组（如果可能 - 因为不允许空组）。要生成ONLY组合键，您需要替换它：

for (var i = 1; i <= keys.Count; i++)

有了这个：

for (var i = 1; i < keys.Count; i++)

在GroupCombined方法的开头。用三个员工和三个工作来测试方法，看看它是如何工作的。

另一个编辑：

更好的重复处理将处理GroupCombined级别中的重复键组合：

public static IEnumerable<ILookup<TKey[], TValue>> GroupCombined<TKey, TValue>
    (List<TKey> keys,
     List<TValue> values)
{
    for (var i = 1; i <= keys.Count; i++)
    {
        var prevs = new List<TKey[][]>();

        foreach (var lookup in Group(Enumerable.Range(0, i).ToList(), keys))
        {
            var found = false;
            var curr = lookup.Select(sub => sub.OrderBy(k => k).ToArray())
                .OrderBy(arr => arr.FirstOrDefault()).ToArray();

            foreach (var prev in prevs.Where(prev => prev.Length == curr.Length))
            {
                var isDuplicate = true;

                for (var x = 0; x < prev.Length; x++)
                {
                    var currSub = curr[x];
                    var prevSub = prev[x];

                    if (currSub.Length != prevSub.Length ||
                        !currSub.SequenceEqual(prevSub))
                    {
                        isDuplicate = false;
                        break;
                    }
                }

                if (isDuplicate)
                {
                    found = true;
                    break;
                }
            }

            if (found)
            {
                continue;
            }

            prevs.Add(curr);

            foreach (var group in
                     Group(lookup.Select(keysComb => keysComb.ToArray()).ToList(),
                           values))
            {
                yield return group;
            }
        }
    }
}

看起来，为方法添加约束是明智的，这样TKey将ICompareable<TKey>，也可能IEquatable<TKey>。

这导致最后有0个重复。

Answer 4

假设我们有两套，A和B. A = {a1, a2, a3} ; B = {b1, b2, b3}

首先，让我们得到一个由包含子集的元组及其补集组成的集合：

{a1} {a2 a3} 
{a2} {a1 a3}
{a3} {a1 a2}
{a2, a3} {a1}
...

为此，您可以使用上面的Rikon库，或编写自己的代码。你需要这样做：

获取一组所有子集（称为电源设置）
对于每个子集，从更大的集合中获取该子集的补充或剩余元素。
将这些加入元组或对中;例如（子集，补充）

订单在这里很重要;毕竟，{a1} {a2 a3} and {a2 a3} {a1}是不同的元组。

然后我们为B得到一个类似的集合。然后，我们在两个集合之间执行交叉连接，得到：

{a1} {a2 a3} | {b1} {b2 b3}

{a2} {a1 a3} | {b2} {b1 b3}
...

这与上面的描述非常匹配。只需将{Bob，Adam}视为一组，将{1,2,3}视为另一组。您必须转储一些空集（因为电源集也包含空子集），具体取决于您的要求。不过，据我所知，这是一般要点。很抱歉缺少代码;我得去睡觉了：P

Answer 5

忽略您的其他约束（例如团队的最大大小），您正在做的是创建set P 的分区和set Q 的分区子集数量，然后查找其中一个集合的所有组合，以将第一个分区映射到第二个分区。

迈克尔奥尔洛夫的论文似乎是一个简单的算法，用于生成分区，其中每次迭代使用this paper中的常量空间。他还提供了一种列出给定大小的分区的算法。

从 P = {A，B} 和 Q = {1,2,3} 开始，然后大小为1的分区为 [P] < / em>和 [Q] ，所以唯一的配对是（[P]，[Q]）

对于大小为2的分区， P 只有两个元素，因此只有一个大小为2的分区 [{A}，{B}] ， Q < / em>有三个大小为2的分区 [{1}，{2,3}]，[{1,2}，{3}]，[{1,3}，{2}] 。

由于 Q 的每个分区都包含两个子集，因此每个分区有2个组合，它们为您提供六个配对：

( [ { A }, { B } ], [ { 1 }, { 2, 3 } ] ) ( [ { A }, { B } ], [ { 2, 3 }, { 1 } ] ) ( [ { A }, { B } ], [ { 1, 2 }, { 3 } ] ) ( [ { A }, { B } ], [ { 3 }, { 1, 2 } ] ) ( [ { A }, { B } ], [ { 1, 3 }, { 2 } ] ) ( [ { A }, { B } ], [ { 2 }, { 1, 3 } ] )

由于其中一个原始集的大小为2，因此没有大小为3的分区，因此我们停止。

用于检索两个列表的每个可能的子列表组合的算法

5 个答案: