有序的独特组合[关闭]

Question

我有以下课程：

internal class Course
{
    public int CourseCode { get; set; }
    public string DeptCode { get; set; }
    public string Name { get; set; }
}

以下代码是我拥有的二维数组：

Course[][] courses = new Course[3][];
courses[0] = new Course[] {
   new Course() { CourseCode = 100, DeptCode = "EGR", Name = "EGR A" },
   new Course() { CourseCode = 100, DeptCode = "EGR", Name = "EGR B" }
};

courses[1] = new Course[] {
   new Course() { CourseCode = 200, DeptCode = "EN", Name = "EN A" }
};

courses[2] = new Course[] {
   new Course() { CourseCode = 300, DeptCode = "PHY", Name = "PHY A" }
};

我想要做的是获得一个组中的每个项目可以与其他组进行的不同组合；例如使用前面的代码，结果将是：

1. EGR A - EN A - PHY A
2. EGR B - EN A - PHY A

答案： 要获得可能的组合数量，我们可以使用Rule of Product，在上述情况下，可能的组合将是(2 * 1 * 1) = 2，这确实是我上面写的2个组合。

LordTakkera 给出了完美的答案，非常感谢！

Answer 1

您可以使用嵌套的 for 循环：

for (int i = 0; i < courses[0].Length; i++)
{
   for (int j = 0; j < courses[1].Length; i++)
   {
     for (int k = 0; k < courses[2].Length; i++)
     {
         //Do whatever you need with the combo, accessed like:
         //courses[0][i], courses[1][j], courses[2][k]
     }
   }
}

当然，您需要的嵌套越多，这个解决方案就会变得非常混乱。如果您需要更深入，我会使用某种递归函数来遍历集合并生成组合。

应该是这样的：

class CombinationHelper
{
    public List<List<Course>> GetAllCombinations(Course[][] courses)
    {
            return GetCourseCombination(courses, 0);
    }

    public List<List<Course>> GetCourseCombination(Course[][] courses, int myIndex)
    {
        List<List<Course>> combos = new List<List<Course>>();

        for (int i = 0; i < courses[myIndex].Length; i++)
        {
            if (myIndex + 1 < courses.GetLength(0))
            {
               foreach (List<Course> combo in GetCourseCombination(courses, myIndex + 1))
               {
                  combo.Add(courses[myIndex][i]);
                  combos.Add(combo);
               }
            }
            else
            {
               List<Course> newCombination = new List<Course>() { courses[myIndex][i] };
               combos.Add(newCombination);
            }
        }
        return combos;
    }
}

我对此进行了测试（用“int”代替“Course”以使验证更容易），它产生了所有 8 种组合（虽然不是按顺序，但递归往往会这样做。如果我想出订购代码，我会发布，但应该不会太困难）。

递归函数对我来说已经够难了，所以我的解释不会很好。基本上，我们从“0”索引开始整个事情（这样我们从头开始）。然后我们遍历当前数组。如果我们不是“主”数组中的最后一个数组，我们将递归到下一个子数组。否则，我们创建一个新组合，将自己添加到其中，然后返回。

随着递归堆栈“展开”，我们将生成的组合添加到返回列表中，将我们自己添加到其中，然后再次返回。最终，整个事情“展开”，你只剩下所有组合的一个列表。

再一次，我确信这是一个非常令人困惑的解释，但递归算法（至少对我而言）本质上是令人困惑的。我很乐意尝试详细说明您想要的任何观点。

Answer 2

看看你的第二个索引 - 0 或 1。如果你只看那个，你会看到一个从 0 到 7 的二进制数。

从 0 数到 7，将其转换为位，得到你需要的组合模式。