C# 如何获取多个列表的所有组合<；int>；

与上面建议的解决方案的不同之处在于，列表项对于每行只能出现一次

这是我的水疗中心的预订系统。不同的员工可以进行不同的处理

我有一个

列表

。这些是可以进行预定治疗的治疗师

每个列表（预订）都包含许多这样的整数（这些是可以执行预订的治疗师）：

我希望看到所有可能的组合，其中数字只能出现在一个地方。对于上述列表，两种可能的组合为：

6,2,1,3或 3,6,1,2

这是第一个组合：

• 预约1:6
• 预约2：治疗师2
• 预约3：治疗师1
• 预约4：治疗师3

---

希望这能让问题更清楚一点。

这个解决方案远远没有效率：

    private static void Main()
    {
        List<List<int>> list = new List<List<int>>
            {
                new List<int>() {1, 3, 6}, //Booking 1
                new List<int>() {1, 2, 6}, //Booking 2
                new List<int>() {1}, //Booking 3
                new List<int>() {2, 3}
            };
        List<int[]> solutions = new List<int[]>();
        int[] solution = new int[list.Count];
        Solve(list, solutions, solution);
    }

    private static void Solve(List<List<int>> list, List<int[]> solutions, int[] solution)
    {
        if (solution.All(i => i != 0) && !solutions.Any(s => s.SequenceEqual(solution)))
            solutions.Add(solution);
        for (int i = 0; i < list.Count; i++)
        {
            if (solution[i] != 0)
                continue; // a caller up the hierarchy set this index to be a number
            for (int j = 0; j < list[i].Count; j++)
            {
                if (solution.Contains(list[i][j]))
                    continue;
                var solutionCopy = solution.ToArray();
                solutionCopy[i] = list[i][j];
                Solve(list, solutions, solutionCopy);
            }
        }
    }

private static void Main（）
{
列表=新列表
{
新列表（）{1,3,6}，//1
新列表（）{1,2,6}，//2
新列表（）{1}，//3
新列表（）{2，3}
};
列表解决方案=新列表（）；
int[]solution=newint[list.Count]；
解决（列表、解决方案、解决方案）；
}
私有静态void Solve（列表、列表解决方案、int[]解决方案）
{
if（solution.All（i=>i！=0）和&！solutions.Any（s=>s.SequenceEqual（solution）））
解决方案。添加（解决方案）；
for（int i=0；i

听起来，使用动态规划可以更有效地解决这个问题，但我已经有一段时间没有学习相关课程了。

递归求解：

static IEnumerable<List<int>> GetCombinations(IEnumerable<List<int>> lists, IEnumerable<int> selected)
{
    if (lists.Any())
    {
        var remainingLists = lists.Skip(1);
        foreach (var item in lists.First().Where(x => !selected.Contains(x)))
            foreach (var combo in GetCombinations(remainingLists, selected.Concat(new int[] { item })))
                yield return combo;
    }
    else
    {
        yield return selected.ToList();
    }
}

static void Main(string[] args)
{
    List<List<int>> lists = new List<List<int>>
    {
        new List<int> { 1, 3, 6 },
        new List<int> { 1, 2, 6 },
        new List<int> { 1 },
        new List<int> { 2, 3 }
    };

    var combos = GetCombinations(lists, new List<int>()).Distinct();

    foreach (var combo in combos)
        Console.WriteLine("{ " + string.Join(", ", combo.Select(x => x.ToString())) + " }");

    return;
}

---

看待这个问题的一个简单方法是从值列表的所有组合中进行选择，其中组合中的每个值都是唯一的

首先找出所有值的组合是什么

public static IEnumerable<IList<T>> Combinations<T>(IEnumerable<IList<T>> collections)
{
    if (collections.Count() == 1)
    {
        foreach (var item in collections.Single())
            yield return new List<T> { item };
    }
    else if (collections.Count() > 1)
    {
        foreach (var item in collections.First())
        foreach (var tail in Combinations(collections.Skip(1)))
            yield return new[] { item }.Concat(tail).ToList();
    }
}

公共静态IEnumerable组合（IEnumerable集合）
{
if（collections.Count（）==1）
{
foreach（collections.Single（）中的var项）
返回新列表{item}；
}
else if（collections.Count（）>1）
{
foreach（collections.First（）中的var项）
foreach（组合中的变量tail（collections.Skip（1）））
返回新的[]{item}.Concat（tail.ToList（）；
}
}

然后需要一种方法来确定所有值是否唯一。一个简单的方法是检查不同值的计数是否等于所有值的计数

public static bool AllUnique<T>(IEnumerable<T> collection)
{
    return collection.Distinct().Count() == collection.Count();
}

public static bool AllUnique（IEnumerable集合）
{
返回collection.Distinct（）.Count（）==collection.Count（）；
}

一旦你拥有了所有这些，把它们放在一起

var collections = new[]
{
    new List<int> { 1, 3, 6 },
    new List<int> { 1, 2, 6 },
    new List<int> { 1 },
    new List<int> { 2, 3 },
};
var results =
    from combination in Combinations(collections)
    where AllUnique(combination)
    select combination;
// results:
//  3,6,1,2
//  6,2,1,3

var collections=new[]
{
新名单{1,3,6}，
新名单{1,2,6}，
新列表{1}，
新名单{2,3}，
};
var结果=
从组合中的组合（集合）
其中AllUnique（组合）
选择组合；
//结果:
//  3,6,1,2
//  6,2,1,3

那你是怎么想到这两种组合的？@SamiHuutoniemi好吧，我不能用其他组合，对吗？不，在这个问题上，数字可以在几个地方。所以所有的组合都是可以接受的。这个问题没有意义。这个解决方案似乎可以通过Distinct（）来解决，但是顺序在哪里呢？我将尝试编辑这个问题，以便更容易理解。非常感谢你！没有那么多，所以性能不是问题。

public static bool AllUnique<T>(IEnumerable<T> collection)
{
    return collection.Distinct().Count() == collection.Count();
}

var collections = new[]
{
    new List<int> { 1, 3, 6 },
    new List<int> { 1, 2, 6 },
    new List<int> { 1 },
    new List<int> { 2, 3 },
};
var results =
    from combination in Combinations(collections)
    where AllUnique(combination)
    select combination;
// results:
//  3,6,1,2
//  6,2,1,3