组合的分组算法

Question

假设我有一个项目列表，每个项目都由一个简单的结构定义

struct simpleItem
{
    String Category1;
    String Category2;
    ...
    String CategoryN;
}

每个项目都有一系列属于某些类别的值。 在处理列表时已知类别数量N，并且每个项目具有相同数量的类别并且每个类别仅具有一个值，没有重复项目。 但是，每个列表可以有不同的类别集。

我正在寻找一种方法来按类别对这些项目进行分组，如果通过组合每个类别的排列将这些组解构为单个项目，我将最终得到原始的组合，没有重复。< / p>

小组结果将是：

struct grouped
{
    String[] Category1;
    String[] Category2;
    ...
    String[] CategoryN;
}

实施例

为了这个例子，我们将限制为3个类别，但可以有N。

类别

动物，眼睛颜色，毛皮

“动物”类别的选择：猫，狗，鼠，马

“眼睛颜色”类别的选择：蓝色，黄色，绿色，红色，橙色

“毛皮”类别的选择：长，短，卷曲

如果列表包含这3个类别的所有排列，则最终结果为

第1组：
动物[猫，狗，大鼠，马]
眼睛颜色[蓝色，黄色，绿色，红色，橙色]
毛[长，短，卷曲]

如果我有一个子列表，例如：

1. Cat，Blue，Long
2. Cat，Blue，Short
3. 狗，蓝色，长
4. 狗，蓝，短
5. 狗，绿龙
6. Rat，Red，Short
7. 鼠，蓝，短

我们打电话给这个列表，输入 （A）

在将这些项目分组后，我们最终会得到:(可能还有其他可能性）。 分组标准是尽可能减少输出组。

第1组：
动物[猫，狗]
         眼睛颜色[蓝色]
     毛[长，短]


第2组：
动物[狗]
         眼睛颜色[绿色]
     毛皮[长]


第3组：
动物[大鼠]
眼睛颜色[红色，蓝色]
毛皮[简要]


我们打电话给这些群组，输出 （B）

正如我们所看到的，通过组合结果组的每个项目，我们将回到 （A） 中的7个元素的原始输入列表。< / p>

问题

所以，我正在尝试编写一个生成这些组的算法。我试图用LINQ做这个，但我也愿意接受其他建议。 关于如何从 （A） 获取 （B） 的任何建议？

Answer 1

1. 将每个输入视为自己的组。
   • 因此，例如，Cat，Blue，Long成为[Cat]，[Blue]，[Long]的组，每个类别只有一个项目。
2. 从第一组开始，浏览列表中的每个组。将其与列表中的其他组配对。如果这些组对符合适当的标准，则将它们组合成一个组。
   • 合并组的条件是，如果n-1类别的值集合相同，并且完全一个类别集不匹配。如果是这种情况，请创建一个新组，其中n-1个相似类别相同，其余类别为集合的交集。
3. 如果找到匹配项，请停止比较对，然后从第一组中的第一项开始。 （在这里使用延迟执行可以帮助您，这样您就不会在找到匹配后立即配对组。）
4. 如果你在没有找到匹配的情况下浏览整套，那么你就完成了，没有更多的组合了。

---

所以，走过你的榜样。首先，它将配对第一组和第二组。前两个类别集是相同的，第三个是不同的，所以它们可以合并。您现在有一个列表：

1. [Cat]，[Blue]， [Long，Short]
2. [狗]，[蓝]，[长]
3. [狗]，[蓝]，[短]
4. [狗]，[绿]，[长]
5. [大鼠]，[红]，[短]
6. [大鼠]，[蓝色]，[短]

接下来，我们比较（新）第一组和第二组。第一个和第三个类别都不匹配，没有合并。接下来我们比较第一个和第三个，同样，两个类别不匹配。第一组不会与任何其他组匹配。所以现在我们进入第二组。我们将它与第三个配对。它可以合并，因为前两个类别不同：

1. [猫]，[蓝]，[长，短]
2. [狗]，[蓝色]， [长，短]
3. [狗]，[绿]，[长]
4. [大鼠]，[红]，[短]
5. [大鼠]，[蓝色]，[短]

现在我们重新开始，将第一组和第二组配对。他们相配。第一类是不同的，第二类是相同的，第三类是相同的。现在是：

1. [猫，狗] ，[蓝色]，[长，短]
2. [狗]，[绿]，[长]
3. [大鼠]，[红]，[短]
4. [大鼠]，[蓝色]，[短]

我们现在将第一个与其他三个中的每一个进行比较，没有一个匹配。然后我们比较第二个和另外两个，没有一个匹配。最后，第三个和第四个匹配，因为只有第二个类别不同：

1. [猫，狗]，[蓝色]，[长，短]
2. [狗]，[绿]，[长]
3. [大鼠]， [红色，蓝色] ，[简短]

最后我们将完成所有组合，没有一个组会匹配合并条件，我们就完成了。